/*******************************************************************************
 * Copyright (c) 2007, 2020 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.api.tools.util.tests;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.filebuffers.FileBuffers;
import org.eclipse.core.filebuffers.ITextFileBuffer;
import org.eclipse.core.filebuffers.ITextFileBufferManager;
import org.eclipse.core.filebuffers.LocationKind;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.Javadoc;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.TagElement;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.pde.api.tools.internal.ApiBaselineManager;
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.Factory;
import org.eclipse.pde.api.tools.internal.provisional.IApiAnnotations;
import org.eclipse.pde.api.tools.internal.provisional.IApiBaselineManager;
import org.eclipse.pde.api.tools.internal.provisional.IApiDescription;
import org.eclipse.pde.api.tools.internal.provisional.RestrictionModifiers;
import org.eclipse.pde.api.tools.internal.provisional.VisibilityModifiers;
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.internal.util.Signatures;
import org.eclipse.pde.api.tools.model.tests.TestSuiteHelper;
import org.eclipse.pde.api.tools.tests.AbstractApiTest;
import org.eclipse.pde.api.tools.tests.util.FileUtils;
import org.eclipse.pde.api.tools.tests.util.ProjectUtils;
import org.eclipse.pde.core.project.IBundleClasspathEntry;
import org.eclipse.pde.core.project.IBundleProjectDescription;
import org.eclipse.pde.core.project.IBundleProjectService;
import org.eclipse.text.edits.MalformedTreeException;
import org.eclipse.text.edits.TextEdit;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * Tests the {@link ApiBaselineManager} without the framework running
 */
@SuppressWarnings("unchecked")
public class ApiBaselineManagerTests extends AbstractApiTest {

	static final String THREE = "three"; //$NON-NLS-1$
	static final String TESTDEFAULT = "testdefault"; //$NON-NLS-1$
	static final String ADDTEST = "addtest"; //$NON-NLS-1$

	class SourceChangeVisitor extends ASTVisitor {
		String name = null;
		String signature = null;
		String tagname = null;
		ASTRewrite rewrite = null;
		boolean remove = false;

		public SourceChangeVisitor(String name, String signature, String tagname, boolean remove, ASTRewrite rewrite) {
			this.name = name;
			this.signature = signature;
			this.tagname = tagname;
			this.rewrite = rewrite;
			this.remove = remove;
		}

		@Override
		public boolean visit(FieldDeclaration node) {
			if (signature != null) {
				return false;
			}
			List<VariableDeclarationFragment> fields = node.fragments();
			VariableDeclarationFragment fragment = null;
			for (Iterator<VariableDeclarationFragment> iter = fields.iterator(); iter.hasNext();) {
				fragment = iter.next();
				if (fragment.getName().getFullyQualifiedName().equals(name)) {
					break;
				}
			}
			if (fragment != null) {
				updateTag(node);
			}
			return false;
		}

		@Override
		public boolean visit(MethodDeclaration node) {
			if (name.equals(node.getName().getFullyQualifiedName())) {
				if (signature.equals(Signatures.getMethodSignatureFromNode(node, true))) {
					updateTag(node);
				}
			}
			return false;
		}

		@Override
		public boolean visit(TypeDeclaration node) {
			if (name.equals(node.getName().getFullyQualifiedName())) {
				updateTag(node);
				return false;
			}
			return true;
		}

		/**
		 * Updates a javadoc tag, by either adding a new one or removing an
		 * existing one
		 *
		 * @param body
		 */
		private void updateTag(BodyDeclaration body) {
			Javadoc docnode = body.getJavadoc();
			AST ast = body.getAST();
			if (docnode == null) {
				docnode = ast.newJavadoc();
				rewrite.set(body, body.getJavadocProperty(), docnode, null);
			}
			ListRewrite lrewrite = rewrite.getListRewrite(docnode, Javadoc.TAGS_PROPERTY);
			if (remove) {
				List<TagElement> tags = (List<TagElement>) docnode.getStructuralProperty(Javadoc.TAGS_PROPERTY);
				if (tags != null) {
					TagElement tag = null;
					for (TagElement tag2 : tags) {
						tag = tag2;
						if (tagname.equals(tag.getTagName())) {
							lrewrite.remove(tag, null);
						}
					}
				}
			} else {
				TagElement newtag = ast.newTagElement();
				newtag.setTagName(tagname);
				lrewrite.insertLast(newtag, null);
			}
		}
	}

	private IPath SRC_LOC = TestSuiteHelper.getPluginDirectoryPath().append("test-source").append("a").append("b").append("c"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
	private IPath PLUGIN_LOC = TestSuiteHelper.getPluginDirectoryPath().append("test-plugins"); //$NON-NLS-1$
	private IApiBaselineManager fPMmanager = ApiPlugin.getDefault().getApiBaselineManager();
	private final String TESTING_PACKAGE = "a.b.c"; //$NON-NLS-1$

	/**
	 * @return the {@link IApiDescription} for the testing project
	 */
	private IApiDescription getTestProjectApiDescription() throws CoreException {
		IApiBaseline baseline = getWorkspaceBaseline();
		assertNotNull("the workspace baseline must exist", baseline); //$NON-NLS-1$
		IApiComponent component = baseline.getApiComponent(TESTING_PLUGIN_PROJECT_NAME);
		if (component != null) {
			return component.getApiDescription();
		}
		return null;
	}

	/**
	 * Creates and returns a test baseline with the given id. Also adds it to
	 * the baseline manager
	 *
	 * @param id
	 * @return
	 */
	protected IApiBaseline getTestBaseline(String id) {
		IApiBaseline baseline = ApiModelFactory.newApiBaseline(id);
		fPMmanager.addApiBaseline(baseline);
		return baseline;
	}

	/**
	 * Tests trying to get the workspace baseline without the framework running
	 */
	@Test
	public void testGetWorkspaceComponent() {
		IApiBaseline baseline = getWorkspaceBaseline();
		assertNotNull("the workspace baseline must not be null", baseline); //$NON-NLS-1$
	}

	/**
	 * Tests that an API baseline can be added and retrieved successfully
	 */
	@Test
	public void testAddBaseline() {
		IApiBaseline baseline = getTestBaseline(ADDTEST);
		assertNotNull("the test baseline must have been created", baseline); //$NON-NLS-1$
		assertTrue("the testadd baseline must be in the manager", fPMmanager.removeApiBaseline(ADDTEST)); //$NON-NLS-1$
	}

	/**
	 * Tests that an API baseline can be added/removed successfully
	 */
	@Test
	public void testRemoveBaseline() {
		IApiBaseline baseline = getTestBaseline("removetest"); //$NON-NLS-1$
		assertNotNull("the testremove baseline must exist", baseline); //$NON-NLS-1$
		baseline = fPMmanager.getApiBaseline("removetest"); //$NON-NLS-1$
		assertNotNull("the testremove baseline must be in the manager", baseline); //$NON-NLS-1$
		assertTrue("the testremove baseline should have been removed", fPMmanager.removeApiBaseline("removetest")); //$NON-NLS-1$ //$NON-NLS-2$
	}

	/**
	 * Tests that the default baseline can be set/retrieved
	 */
	@Test
	public void testSetDefaultBaseline() {
		try {
			IApiBaseline baseline = getTestBaseline(TESTDEFAULT);
			assertNotNull("the testdefault baseline must exist", baseline); //$NON-NLS-1$
			fPMmanager.setDefaultApiBaseline(TESTDEFAULT);
			baseline = fPMmanager.getDefaultApiBaseline();
			assertNotNull("the default baseline must be the testdefault baseline", baseline); //$NON-NLS-1$
		} finally {
			fPMmanager.removeApiBaseline(TESTDEFAULT);
		}
	}

	/**
	 * Tests that all baselines added to the manager can be retrieved
	 */
	@Test
	public void testGetAllBaselines() {
		try {
			fPMmanager.addApiBaseline(getTestBaseline(ADDTEST));
			fPMmanager.addApiBaseline(getTestBaseline(TESTDEFAULT));
			fPMmanager.addApiBaseline(getTestBaseline(THREE));
			IApiBaseline[] baselines = fPMmanager.getApiBaselines();
			assertEquals("there should be three baselines", 3, baselines.length); //$NON-NLS-1$
		} finally {
			fPMmanager.removeApiBaseline(ADDTEST);
			fPMmanager.removeApiBaseline(TESTDEFAULT);
			fPMmanager.removeApiBaseline(THREE);
		}
	}

	/**
	 * Tests that all of the baselines have been removed
	 */
	@Test
	public void testCleanUpMmanager() {
		try {
			fPMmanager.addApiBaseline(getTestBaseline(ADDTEST));
			fPMmanager.addApiBaseline(getTestBaseline(TESTDEFAULT));
			fPMmanager.addApiBaseline(getTestBaseline(THREE));
			IApiBaseline[] baselines = fPMmanager.getApiBaselines();
			assertEquals("there should be three baselines", 3, baselines.length); //$NON-NLS-1$
			assertTrue("the testadd baseline should have been removed", fPMmanager.removeApiBaseline(ADDTEST)); //$NON-NLS-1$
			assertTrue("the testdefault baseline should have been removed", fPMmanager.removeApiBaseline(TESTDEFAULT)); //$NON-NLS-1$
			assertTrue("the three baseline should have been removed", fPMmanager.removeApiBaseline(THREE)); //$NON-NLS-1$
			assertEquals("There sould be no more baselines", 0, fPMmanager.getApiBaselines().length); //$NON-NLS-1$
		} finally {
			fPMmanager.removeApiBaseline(ADDTEST);
			fPMmanager.removeApiBaseline(TESTDEFAULT);
			fPMmanager.removeApiBaseline(THREE);
		}
	}

	/**
	 * Adds the given source to the given package in the given fragment root
	 *
	 * @param root the root to add the source to
	 * @param packagename the name of the package e.g. a.b.c
	 * @param sourcename the name of the source file without an extension e.g.
	 *            TestClass1
	 */
	public void assertTestSource(IPackageFragmentRoot root, String packagename, String sourcename) throws InvocationTargetException, IOException {
		IPackageFragment fragment = root.getPackageFragment(packagename);
		FileUtils.importFileFromDirectory(SRC_LOC.append(sourcename + ".java").toFile(), fragment.getPath(), new NullProgressMonitor()); //$NON-NLS-1$
	}

	/**
	 * Adds the package with the given name to the given package fragment root
	 *
	 * @param the project to add the package to
	 * @param srcroot the absolute path to the package fragment root to add the
	 *            new package to
	 * @param packagename the name of the new package
	 * @return the new {@link IPackageFragment} or <code>null</code>
	 */
	public IPackageFragment assertTestPackage(IJavaProject project, IPath srcroot, String packagename) throws JavaModelException {
		IPackageFragment fragment = null;
		IPackageFragmentRoot root = project.findPackageFragmentRoot(srcroot);
		assertNotNull("the 'src' package fragment root must exist", root); //$NON-NLS-1$
		fragment = root.createPackageFragment(packagename, true, new NullProgressMonitor());
		assertNotNull("the new package '" + packagename + "' should have been created", fragment); //$NON-NLS-1$ //$NON-NLS-2$
		return fragment;
	}

	/**
	 * Adds a test library with the given name to the test projects' class path.
	 * The library is imported from the {@link #PLUGIN_LOC} location.
	 *
	 * @param project the project to add the library classpath entry to
	 * @param folderpath the path in the project where the library should be
	 *            imported to
	 * @param libname the name of the library
	 */
	public IFolder assertTestLibrary(IJavaProject project, IPath folderpath, String libname) throws CoreException, InvocationTargetException, IOException {
		IFolder folder = null;
		// import library
		folder = project.getProject().getFolder(folderpath);
		if (!folder.exists()) {
			folder.create(false, true, null);
		}
		FileUtils.importFileFromDirectory(PLUGIN_LOC.append(libname).toFile(), folder.getFullPath(), null);
		IPath libPath = folder.getFullPath().append(libname);

		// add to manifest bundle classpath
		ProjectUtils.addBundleClasspathEntry(project.getProject(), ProjectUtils.getBundleProjectService().newBundleClasspathEntry(null, null, libPath.removeFirstSegments(1)));
		waitForAutoBuild();
		return folder;
	}

	/**
	 * Asserts if the given restriction is on the specified source
	 *
	 * @param packagename
	 * @param sourcename
	 */
	public void assertSourceResctriction(String packagename, String sourcename, int restriction) throws CoreException {
		IApiDescription desc = getTestProjectApiDescription();
		assertNotNull("the testing project api description must exist", desc); //$NON-NLS-1$
		IApiAnnotations annot = desc.resolveAnnotations(Factory.typeDescriptor(packagename + "." + sourcename)); //$NON-NLS-1$
		assertNotNull("the annotations for " + packagename + "." + sourcename + " cannot be null", annot); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		assertEquals("there must be a noinstantiate setting for TestClass1", annot.getRestrictions(), restriction); //$NON-NLS-1$
	}

	/**
	 * Tests that closing an API aware project causes the workspace description
	 * to be updated
	 */
	@Test
	public void testWPUpdateProjectClosed() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$
		assertNotNull("the workspace baseline must not be null", getWorkspaceBaseline()); //$NON-NLS-1$
		IApiComponent component = getWorkspaceBaseline().getApiComponent(TESTING_PLUGIN_PROJECT_NAME);
		assertNotNull("the change project api component must exist in the workspace baseline", component); //$NON-NLS-1$
		project.getProject().close(new NullProgressMonitor());
		component = getWorkspaceBaseline().getApiComponent(TESTING_PLUGIN_PROJECT_NAME);
		assertNull("the test project api component should no longer exist in the workspace baseline", component); //$NON-NLS-1$
	}

	/**
	 * Tests that opening an API aware project causes the workspace description
	 * to be updated
	 */
	@Test
	public void testWPUpdateProjectOpen() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$
		if (project.getProject().isAccessible()) {
			project.getProject().close(new NullProgressMonitor());
		}
		project.getProject().open(new NullProgressMonitor());
		IApiBaseline baseline = getWorkspaceBaseline();
		assertNotNull("the workspace baseline must not be null", baseline); //$NON-NLS-1$
		IApiComponent component = baseline.getApiComponent(TESTING_PLUGIN_PROJECT_NAME);
		assertNotNull("the test project api component must exist in the workspace baseline", component); //$NON-NLS-1$
	}

	/**
	 * Tests that adding a source file to an API aware project causes the
	 * workspace description to be updated This test adds
	 * <code>a.b.c.TestClass1</code> to the plug-in project
	 */
	@Test
	public void testWPUpdateSourceAdded() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$
		IPackageFragmentRoot root = project.findPackageFragmentRoot(new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute().makeAbsolute());
		assertNotNull("the 'src' package fragment root must exist", root); //$NON-NLS-1$
		assertTestSource(root, TESTING_PACKAGE, "TestClass1"); //$NON-NLS-1$
		assertSourceResctriction(TESTING_PACKAGE, "TestClass1", RestrictionModifiers.NO_INSTANTIATE); //$NON-NLS-1$
	}

	/**
	 * Tests that removing a source file from an API aware project causes the
	 * workspace description to be updated
	 */
	@Test
	public void testWPUpdateSourceRemoved() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$
		IPackageFragmentRoot root = project.findPackageFragmentRoot(new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute());
		assertNotNull("the 'src' package fragment root must exist", root); //$NON-NLS-1$
		assertTestSource(root, TESTING_PACKAGE, "TestClass1"); //$NON-NLS-1$
		IJavaElement element = project.findElement(new Path("a/b/c/TestClass1.java")); //$NON-NLS-1$
		assertNotNull("the class a.b.c.TestClass1 must exist in the project", element); //$NON-NLS-1$
		element.getResource().delete(true, new NullProgressMonitor());
		IApiDescription desc = getTestProjectApiDescription();
		assertNotNull("the testing project api description must exist", desc); //$NON-NLS-1$
		IApiAnnotations annot = desc.resolveAnnotations(Factory.typeDescriptor("a.b.c.TestClass1")); //$NON-NLS-1$
		assertNull("the annotations for a.b.c.TestClass1 should no longer be present", annot); //$NON-NLS-1$
	}

	/**
	 * Adds the specified tag to the source member defined by the member name
	 * and signature
	 *
	 * @param unit
	 * @param membername
	 * @param signature
	 * @param tagname
	 * @param remove
	 * @throws CoreException
	 * @throws MalformedTreeException
	 * @throws BadLocationException
	 */
	private void updateTagInSource(ICompilationUnit unit, String membername, String signature, String tagname, boolean remove) throws CoreException, MalformedTreeException, BadLocationException {
		ASTParser parser = ASTParser.newParser(AST.JLS14);
		parser.setSource(unit);
		CompilationUnit cunit = (CompilationUnit) parser.createAST(new NullProgressMonitor());
		assertNotNull("the ast compilation unit cannot be null", cunit); //$NON-NLS-1$
		cunit.recordModifications();
		ASTRewrite rewrite = ASTRewrite.create(cunit.getAST());
		cunit.accept(new SourceChangeVisitor(membername, signature, tagname, remove, rewrite));
		ITextFileBufferManager bm = FileBuffers.getTextFileBufferManager();
		IPath path = cunit.getJavaElement().getPath();
		try {
			bm.connect(path, LocationKind.IFILE, null);
			ITextFileBuffer tfb = bm.getTextFileBuffer(path, LocationKind.IFILE);
			IDocument document = tfb.getDocument();
			TextEdit edits = rewrite.rewriteAST(document, null);
			edits.apply(document);
			tfb.commit(new NullProgressMonitor(), true);
		} finally {
			bm.disconnect(path, LocationKind.IFILE, null);
		}
	}

	/**
	 * Tests that making Javadoc changes to the source file TestClass2 cause the
	 * workspace baseline to be updated.
	 *
	 * This test adds a @noinstantiate tag to the source file TestClass2
	 */
	@Test
	public void testWPUpdateSourceTypeChanged() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$
		IPackageFragmentRoot root = project.findPackageFragmentRoot(new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute());
		assertNotNull("the 'src' package fragment root must exist", root); //$NON-NLS-1$
		NullProgressMonitor monitor = new NullProgressMonitor();
		IPackageFragment fragment = root.getPackageFragment("a.b.c"); //$NON-NLS-1$
		FileUtils.importFileFromDirectory(SRC_LOC.append("TestClass2.java").toFile(), fragment.getPath(), monitor); //$NON-NLS-1$
		ICompilationUnit element = (ICompilationUnit) project.findElement(new Path("a/b/c/TestClass2.java")); //$NON-NLS-1$
		assertNotNull("TestClass2 must exist in the test project", element); //$NON-NLS-1$
		updateTagInSource(element, "TestClass2", null, "@noinstantiate", false); //$NON-NLS-1$ //$NON-NLS-2$
		IApiDescription desc = getTestProjectApiDescription();
		assertNotNull("the testing project api description must exist", desc); //$NON-NLS-1$
		IApiAnnotations annot = desc.resolveAnnotations(Factory.typeDescriptor("a.b.c.TestClass2")); //$NON-NLS-1$
		assertNotNull("the annotations for a.b.c.TestClass2 cannot be null", annot); //$NON-NLS-1$
		assertTrue("there must be a noinstantiate setting for TestClass2", (annot.getRestrictions() & RestrictionModifiers.NO_INSTANTIATE) != 0); //$NON-NLS-1$
		assertTrue("there must be a noextend setting for TestClass2", (annot.getRestrictions() & RestrictionModifiers.NO_EXTEND) != 0); //$NON-NLS-1$
	}

	/**
	 * Tests that tags updated on an inner type are updated in the workspace
	 * description.
	 *
	 * This test adds a @noinstantiate tag to an inner class in TestClass3
	 */
	@Test
	public void testWPUpdateSourceInnerTypeChanged() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$
		IPackageFragmentRoot root = project.findPackageFragmentRoot(new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute());
		assertNotNull("the 'src' package fragment root must exist", root); //$NON-NLS-1$
		assertTestSource(root, TESTING_PACKAGE, "TestClass3"); //$NON-NLS-1$
		ICompilationUnit element = (ICompilationUnit) project.findElement(new Path("a/b/c/TestClass3.java")); //$NON-NLS-1$
		assertNotNull("TestClass3 must exist in the test project", element); //$NON-NLS-1$
		updateTagInSource(element, "InnerTestClass3", null, "@noinstantiate", false); //$NON-NLS-1$ //$NON-NLS-2$
		IApiDescription desc = getTestProjectApiDescription();
		assertNotNull("the testing project api description must exist", desc); //$NON-NLS-1$
		IApiAnnotations annot = desc.resolveAnnotations(Factory.typeDescriptor("a.b.c.TestClass3$InnerTestClass3")); //$NON-NLS-1$
		assertNotNull("the annotations for a.b.c.TestClass3$InnerTestClass3 cannot be null", annot); //$NON-NLS-1$
		assertFalse("there must not be a noinstantiate setting for TestClass3$InnerTestClass3", (annot.getRestrictions() & RestrictionModifiers.NO_INSTANTIATE) != 0); //$NON-NLS-1$
		assertFalse("there must not be a noextend setting for TestClass3$InnerTestClass3", (annot.getRestrictions() & RestrictionModifiers.NO_EXTEND) != 0); //$NON-NLS-1$
	}

	/**
	 * Tests that changing the javadoc for a method updates the workspace
	 * baseline
	 *
	 * This test adds a @noextend tag to the method foo() in TestClass1
	 */
	@Test
	public void testWPUpdateSourceMethodChanged() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$
		IPackageFragmentRoot root = project.findPackageFragmentRoot(new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute());
		assertNotNull("the 'src' package fragment root must exist", root); //$NON-NLS-1$
		assertTestSource(root, TESTING_PACKAGE, "TestClass1"); //$NON-NLS-1$
		ICompilationUnit element = (ICompilationUnit) project.findElement(new Path("a/b/c/TestClass1.java")); //$NON-NLS-1$
		assertNotNull("TestClass1 must exist in the test project", element); //$NON-NLS-1$
		updateTagInSource(element, "foo", "()V", "@nooverride", false); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		IApiDescription desc = getTestProjectApiDescription();
		assertNotNull("the testing project api description must exist", desc); //$NON-NLS-1$
		IApiAnnotations annot = desc.resolveAnnotations(Factory.methodDescriptor("a.b.c.TestClass1", "foo", "()V")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		assertNotNull("the annotations for foo() cannot be null", annot); //$NON-NLS-1$
		assertTrue("there must be a nooverride setting for foo()", (annot.getRestrictions() & RestrictionModifiers.NO_OVERRIDE) != 0); //$NON-NLS-1$
	}

	/**
	 * Tests that changing the javadoc for a field updates the workspace
	 * baseline
	 *
	 * This test adds a @noextend tag to the field 'field' in TestField9
	 */
	@Test
	public void testWPUpdateSourceFieldChanged() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$
		IPackageFragmentRoot root = project.findPackageFragmentRoot(new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute());
		assertNotNull("the 'src' package fragment root must exist", root); //$NON-NLS-1$
		assertTestSource(root, TESTING_PACKAGE, "TestField9"); //$NON-NLS-1$
		ICompilationUnit element = (ICompilationUnit) project.findElement(new Path("a/b/c/TestField9.java")); //$NON-NLS-1$
		assertNotNull("TestField9 must exist in the test project", element); //$NON-NLS-1$
		updateTagInSource(element, "field", null, "@noreference", false); //$NON-NLS-1$ //$NON-NLS-2$
		IApiDescription desc = getTestProjectApiDescription();
		assertNotNull("the testing project api description must exist", desc); //$NON-NLS-1$
		IApiAnnotations annot = desc.resolveAnnotations(Factory.fieldDescriptor("a.b.c.TestField9", "field")); //$NON-NLS-1$ //$NON-NLS-2$
		assertNotNull("the annotations for 'field' cannot be null", annot); //$NON-NLS-1$
		assertTrue("there must be a noreference setting for 'field'", (annot.getRestrictions() & RestrictionModifiers.NO_REFERENCE) != 0); //$NON-NLS-1$
	}

	/**
	 * Tests that removing a tag from a method updates the workspace baseline
	 *
	 * This test removes a @noextend tag to the method foo() in TestClass1
	 */
	@Test
	public void testWPUpdateSourceMethodRemoveTag() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$
		IPackageFragmentRoot root = project.findPackageFragmentRoot(new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute());
		assertNotNull("the 'src' package fragment root must exist", root); //$NON-NLS-1$
		assertTestSource(root, TESTING_PACKAGE, "TestClass1"); //$NON-NLS-1$
		ICompilationUnit element = (ICompilationUnit) project.findElement(new Path("a/b/c/TestClass1.java")); //$NON-NLS-1$
		assertNotNull("TestClass1 must exist in the test project", element); //$NON-NLS-1$
		updateTagInSource(element, "foo", "()V", "@nooverride", true); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		IApiDescription desc = getTestProjectApiDescription();
		assertNotNull("the testing project api description must exist", desc); //$NON-NLS-1$
		IApiAnnotations annot = desc.resolveAnnotations(Factory.methodDescriptor("a.b.c.TestClass1", "foo", "()V")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		assertNotNull("the annotations for foo() cannot be null", annot); //$NON-NLS-1$
		assertTrue("there must be no restrictions for foo()", annot.getRestrictions() == 0); //$NON-NLS-1$
	}

	/**
	 * Tests that removing a tag from a type updates the workspace baseline
	 *
	 * This test removes a @noinstantiate tag to an inner class in TestClass3
	 */
	@Test
	public void testWPUpdateSourceTypeRemoveTag() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$
		IPackageFragmentRoot root = project.findPackageFragmentRoot(new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute());
		assertNotNull("the 'src' package fragment root must exist", root); //$NON-NLS-1$
		assertTestSource(root, TESTING_PACKAGE, "TestClass3"); //$NON-NLS-1$
		ICompilationUnit element = (ICompilationUnit) project.findElement(new Path("a/b/c/TestClass3.java")); //$NON-NLS-1$
		assertNotNull("TestClass3 must exist in the test project", element); //$NON-NLS-1$
		updateTagInSource(element, "InnerTestClass3", null, "@noextend", true); //$NON-NLS-1$ //$NON-NLS-2$
		IApiDescription desc = getTestProjectApiDescription();
		assertNotNull("the testing project api description must exist", desc); //$NON-NLS-1$
		IApiAnnotations annot = desc.resolveAnnotations(Factory.typeDescriptor("a.b.c.TestClass3$InnerTestClass3")); //$NON-NLS-1$
		assertNotNull("the annotations for 'InnerTestClass3' cannot be null", annot); //$NON-NLS-1$
		assertTrue("there must be a no restrictions for 'InnerTestClass3'", (annot.getRestrictions() & RestrictionModifiers.NO_INSTANTIATE) == 0); //$NON-NLS-1$
	}

	/**
	 * Tests that removing a tag from a field updates the workspace baseline
	 *
	 * This test adds a @noextend tag to the field 'field' in TestField9
	 */
	@Test
	public void testWPUpdateSourceFieldRemoveTag() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$
		IPackageFragmentRoot root = project.findPackageFragmentRoot(new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute());
		assertNotNull("the 'src' package fragment root must exist", root); //$NON-NLS-1$
		assertTestSource(root, TESTING_PACKAGE, "TestField9"); //$NON-NLS-1$
		ICompilationUnit element = (ICompilationUnit) project.findElement(new Path("a/b/c/TestField9.java")); //$NON-NLS-1$
		assertNotNull("TestField9 must exist in the test project", element); //$NON-NLS-1$
		updateTagInSource(element, "field1", null, "@noreference", true); //$NON-NLS-1$ //$NON-NLS-2$
		IApiDescription desc = getTestProjectApiDescription();
		assertNotNull("the testing project api description must exist", desc); //$NON-NLS-1$
		IApiAnnotations annot = desc.resolveAnnotations(Factory.fieldDescriptor("a.b.c.TestField9", "field")); //$NON-NLS-1$ //$NON-NLS-2$
		assertNotNull("the annotations for 'field' cannot be null", annot); //$NON-NLS-1$
		assertTrue("there must be a no restrictions for 'field'", annot.getRestrictions() == 0); //$NON-NLS-1$
	}

	/**
	 * Tests that a library added to the build and bundle class path of a
	 * project causes the class file containers for the project to need to be
	 * recomputed
	 *
	 * @throws IOException
	 * @throws InvocationTargetException
	 * @throws CoreException
	 */
	@Test
	public void testWPUpdateLibraryAddedToClasspath() throws Exception {
		IFolder folder = null;
		try {
			IJavaProject project = getTestingProject();
			assertNotNull("The testing project must exist", project); //$NON-NLS-1$
			IApiComponent component = getWorkspaceBaseline().getApiComponent(project.getElementName());
			assertNotNull("the workspace component must exist", component); //$NON-NLS-1$
			int before = component.getApiTypeContainers().length;

			// add to classpath
			folder = assertTestLibrary(project, new Path("libx"), "component.a_1.0.0.jar"); //$NON-NLS-1$ //$NON-NLS-2$
			assertNotNull("The new library path should not be null", folder); //$NON-NLS-1$

			// re-retrieve updated component
			component = getWorkspaceBaseline().getApiComponent(project.getElementName());
			assertTrue("there must be more containers after the addition", before < component.getApiTypeContainers().length); //$NON-NLS-1$
		} finally {
			if (folder != null) {
				FileUtils.delete(folder);
			}
		}
	}

	/**
	 * Tests removing a library from the classpath of a project
	 */
	@Test
	public void testWPUpdateLibraryRemovedFromClasspath() throws Exception {
		IPath libPath = null;
		try {
			IJavaProject project = getTestingProject();
			assertNotNull("The testing project must exist", project); //$NON-NLS-1$

			// add to classpath
			IFolder folder = assertTestLibrary(project, new Path("libx"), "component.a_1.0.0.jar"); //$NON-NLS-1$ //$NON-NLS-2$
			IApiComponent component = getWorkspaceBaseline().getApiComponent(project.getElementName());
			assertNotNull("the workspace component must exist", component); //$NON-NLS-1$
			int before = component.getApiTypeContainers().length;
			libPath = folder.getFullPath().append("component.a_1.0.0.jar"); //$NON-NLS-1$

			// remove classpath entry
			ProjectUtils.removeFromClasspath(project, JavaCore.newLibraryEntry(libPath, null, null));
			waitForAutoBuild();

			// remove from bundle class path
			IBundleProjectService service = ProjectUtils.getBundleProjectService();
			IBundleProjectDescription description = service.getDescription(project.getProject());
			description.setBundleClasspath(new IBundleClasspathEntry[] { service.newBundleClasspathEntry(new Path(ProjectUtils.SRC_FOLDER), null, null) });
			description.apply(null);
			waitForAutoBuild();

			// retrieve updated component
			component = getWorkspaceBaseline().getApiComponent(project.getElementName());
			assertTrue("there must be less containers after the removal", before > component.getApiTypeContainers().length); //$NON-NLS-1$
		} finally {
			if (libPath != null) {
				FileUtils.delete(libPath.toOSString());
			}
		}
	}

	/**
	 * Tests that changing the output folder settings for a project cause the
	 * class file containers to be updated
	 */
	@Test
	public void testWPUpdateDefaultOutputFolderChanged() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$
		IContainer container = ProjectUtils.addFolderToProject(project.getProject(), "bin2"); //$NON-NLS-1$
		assertNotNull("the new output folder cannot be null", container); //$NON-NLS-1$
		IApiComponent component = getWorkspaceBaseline().getApiComponent(project.getElementName());
		assertNotNull("the workspace component must exist", component); //$NON-NLS-1$
		int before = component.getApiTypeContainers().length;
		project.setOutputLocation(container.getFullPath(), new NullProgressMonitor());
		waitForAutoBuild();
		assertTrue("there must be the same number of containers after the change", before == component.getApiTypeContainers().length); //$NON-NLS-1$
		assertTrue("the new output location should be 'bin2'", "bin2".equalsIgnoreCase(project.getOutputLocation().toFile().getName())); //$NON-NLS-1$ //$NON-NLS-2$
	}

	/**
	 * Tests that the output folder settings for a source folder cause the class
	 * file containers to be updated
	 */
	@Test
	public void testWPUpdateOutputFolderSrcFolderChanged() throws Exception {
		IJavaProject project = getTestingProject();
		IApiComponent component = getWorkspaceBaseline().getApiComponent(project.getElementName());
		assertNotNull("the workspace component must exist", component); //$NON-NLS-1$
		int before = component.getApiTypeContainers().length;

		ProjectUtils.addFolderToProject(project.getProject(), "bin3"); //$NON-NLS-1$
		IContainer container = ProjectUtils.addFolderToProject(project.getProject(), "src2"); //$NON-NLS-1$
		// add to bundle class path
		IBundleProjectService service = ProjectUtils.getBundleProjectService();
		IBundleClasspathEntry next = service.newBundleClasspathEntry(new Path("src2"), new Path("bin3"), new Path("next.jar")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		ProjectUtils.addBundleClasspathEntry(project.getProject(), next);
		waitForAutoBuild();

		// retrieve updated component
		component = getWorkspaceBaseline().getApiComponent(project.getElementName());
		assertTrue("there must be one more container after the change", before < component.getApiTypeContainers().length); //$NON-NLS-1$
		IPackageFragmentRoot root = project.getPackageFragmentRoot(container);
		assertTrue("the class file container for src2 must be 'bin3'", "bin3".equals(root.getRawClasspathEntry().getOutputLocation().toFile().getName())); //$NON-NLS-1$ //$NON-NLS-2$
	}

	/**
	 * Tests that adding a package does not update the workspace baseline
	 */
	@Test
	public void testWPUpdatePackageAdded() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$

		// add the package
		assertTestPackage(project, new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute(), "a.test1.c.d"); //$NON-NLS-1$

		IApiDescription desc = getTestProjectApiDescription();
		assertNotNull("the testing project api description must exist", desc); //$NON-NLS-1$
		IApiAnnotations annot = desc.resolveAnnotations(Factory.packageDescriptor("a.test1.c.d")); //$NON-NLS-1$
		assertNotNull("the annotations for package " + TESTING_PACKAGE + " should exist", annot); //$NON-NLS-1$ //$NON-NLS-2$
	}

	/**
	 * Tests that removing a package updates the workspace baseline This test
	 * removes the a.b.c package being used in all tests thus far, and should be
	 * run last
	 */
	@Test
	public void testWPUpdatePackageRemoved() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$

		// add the package
		IPath srcroot = new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute();
		IPackageFragment fragment = assertTestPackage(project, srcroot, "a.test2"); //$NON-NLS-1$
		assertNotNull("the package " + TESTING_PACKAGE + " must exist", fragment); //$NON-NLS-1$ //$NON-NLS-2$

		// remove the package
		fragment.delete(true, new NullProgressMonitor());

		IApiDescription desc = getTestProjectApiDescription();
		assertNotNull("the testing project api description must exist", desc); //$NON-NLS-1$
		IApiAnnotations annot = desc.resolveAnnotations(Factory.packageDescriptor("a.test2")); //$NON-NLS-1$
		assertNull("the annotations for package " + TESTING_PACKAGE + " should not exist", annot); //$NON-NLS-1$ //$NON-NLS-2$
	}

	/**
	 * Tests that an exported package addition in the PDE model is reflected in
	 * the workspace api baseline
	 */
	@Test
	public void testWPUpdateExportPackageAdded() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$

		// add package
		assertTestPackage(project, new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute(), "export1"); //$NON-NLS-1$

		// update
		setPackageToApi(project, "export1"); //$NON-NLS-1$
		IApiAnnotations annot = getTestProjectApiDescription().resolveAnnotations(Factory.packageDescriptor("export1")); //$NON-NLS-1$
		assertNotNull("there must be an annotation for the new exported package", annot); //$NON-NLS-1$
		assertTrue("the newly exported package must be API visibility", annot.getVisibility() == VisibilityModifiers.API); //$NON-NLS-1$
	}

	/**
	 * Tests that changing a directive to x-internal on an exported package
	 * causes the workspace api baseline to be updated
	 */
	@Test
	public void testWPUPdateExportPackageDirectiveChangedToInternal() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$

		// add package
		assertTestPackage(project, new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute(), "export1"); //$NON-NLS-1$

		// export the package
		ProjectUtils.addExportedPackage(project.getProject(), "export1", true, null); //$NON-NLS-1$

		// check the description
		IApiAnnotations annot = getTestProjectApiDescription().resolveAnnotations(Factory.packageDescriptor("export1")); //$NON-NLS-1$
		assertNotNull("there must be an annotation for the new exported package", annot); //$NON-NLS-1$
		assertTrue("the changed exported package must be PRIVATE visibility", annot.getVisibility() == VisibilityModifiers.PRIVATE); //$NON-NLS-1$
	}

	/**
	 * Tests that an exported package removal in the PDE model is reflected in
	 * the workspace api baseline
	 */
	@Test
	public void testWPUpdateExportPackageRemoved() throws Exception {
		IJavaProject project = getTestingProject();
		assertNotNull("The testing project must exist", project); //$NON-NLS-1$

		// add package
		assertTestPackage(project, new Path(project.getElementName()).append(ProjectUtils.SRC_FOLDER).makeAbsolute(), "export1"); //$NON-NLS-1$

		setPackageToApi(project, "export1"); //$NON-NLS-1$
		IApiAnnotations annot = getTestProjectApiDescription().resolveAnnotations(Factory.packageDescriptor("export1")); //$NON-NLS-1$
		assertNotNull("there must be an annotation for the new exported package", annot); //$NON-NLS-1$
		assertTrue("the newly exported package must be API visibility", annot.getVisibility() == VisibilityModifiers.API); //$NON-NLS-1$

		// remove exported packages
		IBundleProjectService service = ProjectUtils.getBundleProjectService();
		IBundleProjectDescription description = service.getDescription(project.getProject());
		description.setPackageExports(null);
		description.apply(null);

		// check the API description
		annot = getTestProjectApiDescription().resolveAnnotations(Factory.packageDescriptor("export1")); //$NON-NLS-1$
		assertNotNull("should still be an annotation for the package", annot); //$NON-NLS-1$
		assertTrue("unexported package must be private", VisibilityModifiers.isPrivate(annot.getVisibility())); //$NON-NLS-1$
	}

	/**
	 * sets the given package name to be an Exported-Package
	 *
	 * @param name
	 */
	private void setPackageToApi(IJavaProject project, String name) throws CoreException {
		ProjectUtils.addExportedPackage(project.getProject(), name, false, null);
	}

	IJavaProject getTestingProject() {
		return JavaCore.create(ResourcesPlugin.getWorkspace().getRoot().getProject(TESTING_PLUGIN_PROJECT_NAME));
	}

	@Before
	public void setUp() throws Exception {
		createProject(TESTING_PLUGIN_PROJECT_NAME, new String[] { TESTING_PACKAGE });
		setPackageToApi(getTestingProject(), TESTING_PACKAGE);
	}

	@After
	public void tearDown() throws Exception {
		deleteProject(TESTING_PLUGIN_PROJECT_NAME);
		getWorkspaceBaseline().dispose();
	}
}