tests/org.eclipse.wst.xml.ui.tests/src/org/eclipse/wst/xml/ui/tests/XMLCodeFoldingTest.java - sourceediting/webtools.sourceediting.tests - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009, 2012 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.wst.xml.ui.tests;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import junit.extensions.TestSetup;
 import junit.framework.Assert;
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;

 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.Position;
 import org.eclipse.jface.text.source.Annotation;
 import org.eclipse.jface.text.source.IAnnotationModel;
 import org.eclipse.jface.text.source.projection.ProjectionAnnotation;
 import org.eclipse.jface.text.source.projection.ProjectionAnnotationModel;
 import org.eclipse.ui.IEditorPart;
 import org.eclipse.ui.IWorkbenchPage;
 import org.eclipse.ui.IWorkbenchWindow;
 import org.eclipse.ui.PlatformUI;
 import org.eclipse.ui.ide.IDE;
 import org.eclipse.wst.sse.core.utils.StringUtils;
 import org.eclipse.wst.sse.ui.StructuredTextEditor;
 import org.eclipse.wst.sse.ui.internal.StructuredTextViewer;
 import org.eclipse.wst.sse.ui.reconcile.ISourceReconcilingListener;
 import org.eclipse.wst.xml.ui.internal.tabletree.XMLMultiPageEditorPart;

 /**
  * <p>Tests that code folding annotations are correctly added/removed from XML Documents</p>
  * <p>All of these tests use the same project and when possible the same open documents</p>
  *
  * @see org.eclipse.wst.xml.ui.tests.XMLCodeFoldingTest Similar Test - XML Code Folding Test
  * @see org.eclipse.wst.css.ui.tests.viewer.CSSCodeFoldingTest Similar Test - CSS Code Folding Test
  * @see org.eclipse.wst.dtd.ui.tests.viewer.DTDCodeFoldingTest Similar Test - DTD Code Folding Test
  */
 public class XMLCodeFoldingTest extends TestCase implements ISourceReconcilingListener {
 	/** max amount of time to wait for */
 	private static final int MAX_WAIT_TIME = 15000;

 	/** amount of time to wait for */
 	private static final int WAIT_TIME = 200;

 	/**
 	 * The name of the project that all of these tests will use
 	 */
 	private static final String PROJECT_NAME = "XMLCodeFoldingTest";

 	/**
 	 * The location of the testing files
 	 */
 	private static final String PROJECT_FILES = "/testresources/folding";

 	/**
 	 * The project that all of the tests use
 	 */
 	private static IProject fProject;

 	/**
 	 * Used to keep track of the already open editors so that the tests don't go through
 	 * the trouble of opening the same editors over and over again
 	 */
 	private static Map fFileToEditorMap = new HashMap();

 	/** the last {@link IDocument} to be reconciled */
 	private static IDocument fReconciledDoc = null;

 	/**
 	 * <p>Default constructor<p>
 	 * <p>Use {@link #suite()}</p>
 	 *
 	 * @see #suite()
 	 */
 	public XMLCodeFoldingTest() {
 		super("XML Code Folding Test");
 	}

 	/**
 	 * <p>Constructor that takes a test name.</p>
 	 * <p>Use {@link #suite()}</p>
 	 *
 	 * @param name The name this test run should have.
 	 *
 	 * @see #suite()
 	 */
 	public XMLCodeFoldingTest(String name) {
 		super(name);
 	}

 	/**
 	 * <p>Use this method to add these tests to a larger test suite so set up
 	 * and tear down can be performed</p>
 	 *
 	 * @return a {@link TestSetup} that will run all of the tests in this class
 	 * with set up and tear down.
 	 */
 	public static Test suite() {
 		TestSuite ts = new TestSuite(XMLCodeFoldingTest.class, "XML Code Folding Test");
 		return new XMLCodeFoldingTestSetup(ts);

 	}

 	/**
 	 * Reset the state between tests
 	 *
 	 * @see junit.framework.TestCase#setUp()
 	 */
 	protected void setUp() throws Exception {
 		super.setUp();

 		fReconciledDoc = null;
 	}

 	/**
 	 * <p><b>TEST:</b> the initially placed folding annotations</p>
 	 */
 	public void testInitFolding() throws Exception {
 		IFile file = getFile("XMLFoldingTest1.xml");

 		StructuredTextEditor editor  = getEditor(file);

 		// expected for single-character line delimiter
 		List expectedPositions = new ArrayList();
 		expectedPositions.add(new Position(142, 16));
 		expectedPositions.add(new Position(173, 36));
 		expectedPositions.add(new Position(39, 179));
 		expectedPositions.add(new Position(71, 13));
 		expectedPositions.add(new Position(62, 107));
 		expectedPositions.add(new Position(47, 13));
 		expectedPositions.add(new Position(87, 49));

 		waitForReconcileThenVerify(editor.getTextViewer(), expectedPositions);
 	}

 	/**
 	 * <p><b>TEST:</b> that folding annotations are updated after node is removed</p>
 	 */
 	public void testRemoveNode() throws Exception {
 		IFile file = getFile("XMLFoldingTest1.xml");

 		StructuredTextEditor editor  = getEditor(file);

 		try {
 			StructuredTextViewer viewer = editor.getTextViewer();
 			IDocument doc = viewer.getDocument();
 			doc.replace(87, 49, "");
 			editor.doSave(null);

 			final List expectedPositions = new ArrayList();
 			expectedPositions.add(new Position(93, 16));
 			expectedPositions.add(new Position(124, 36));
 			expectedPositions.add(new Position(39, 130));
 			expectedPositions.add(new Position(71, 13));
 			expectedPositions.add(new Position(62, 58));
 			expectedPositions.add(new Position(47, 13));

 			waitForReconcileThenVerify(viewer, expectedPositions);
 		} catch(BadLocationException e) {
 			fail("Test is broken, replace location has become invalid.\n" + e.getMessage());
 		}
 	}

 	/**
 	 * <p><b>TEST:</b> that folding annotations are updated after node is added</p>
 	 */
 	public void testAddNode() throws Exception {
 		IFile file = getFile("XMLFoldingTest2.xml");

 		StructuredTextEditor editor  = getEditor(file);

 		try {
 			StructuredTextViewer viewer = editor.getTextViewer();
 			IDocument doc = viewer.getDocument();
 			doc.replace(149, 0, "\n<addMe>\n\n\n</addMe>");
 			editor.doSave(null);

 			List expectedPositions = new ArrayList();
 			expectedPositions.add(new Position(150, 18));
 			expectedPositions.add(new Position(62, 126));
 			expectedPositions.add(new Position(47, 13));
 			expectedPositions.add(new Position(39, 198));
 			expectedPositions.add(new Position(192, 36));
 			expectedPositions.add(new Position(71, 13));
 			expectedPositions.add(new Position(142, 35));
 			expectedPositions.add(new Position(87, 49));

 			waitForReconcileThenVerify(viewer, expectedPositions);
 		} catch(BadLocationException e) {
 			fail("Test is broken, add location has become invalid.\n" + e.getMessage());
 		}
 	}

 	/**
 	 * <p><b>TEST:</b> that even though .xsl documents do not have a specifically specified
 	 * folding strategy that by the power of hierarchical content types the XML folding
 	 * strategy is used for the XSLT document.
 	 */
 	public void testConfigTypeHierarchyExploration() throws Exception{
 		IFile file = getFile("XSLFoldingTest1.xsl");

 		StructuredTextEditor editor = getEditor(file);

 		List expectedPositions = new ArrayList();
 		expectedPositions.add(new Position(120, 88));
 		expectedPositions.add(new Position(147, 44));
 		expectedPositions.add(new Position(39, 187));

 		waitForReconcileThenVerify(editor.getTextViewer(), expectedPositions);
 	}

 	/**
 	 * <p><b>TEST:</b> test the folding of comments</p>
 	 */
 	public void testComments() throws Exception{
 		IFile file = getFile("XMLFoldingCommentTest.xml");

 		StructuredTextEditor editor = getEditor(file);

 		List expectedPositions = new ArrayList();
 		expectedPositions.add(new Position(275, 36));
 		expectedPositions.add(new Position(124, 49));
 		expectedPositions.add(new Position(179, 81));
 		expectedPositions.add(new Position(39, 281));
 		expectedPositions.add(new Position(191, 56));
 		expectedPositions.add(new Position(64, 31));
 		expectedPositions.add(new Position(99, 172));
 		expectedPositions.add(new Position(47, 13));
 		expectedPositions.add(new Position(108, 13));

 		waitForReconcileThenVerify(editor.getTextViewer(), expectedPositions);
 	}

 	/**
 	 * <p>Given a file name in <code>fProject</code> attempts to get an <code>IFile</code>
 	 * for it, if the file doesn't exist the test fails.</p>
 	 *
 	 * @param name the name of the file to get
 	 * @return the <code>IFile</code> associated with the given <code>name</code>
 	 */
 	private static IFile getFile(String name) {
 		IFile file = fProject.getFile(name);
 		assertTrue("Test file " + file + " can not be found", file.exists());

 		return file;
 	}

 	/**
 	 * <p>Given a <code>file</code> get an editor for it. If an editor has already
 	 * been retrieved for the given <code>file</code> then return the same already
 	 * open editor.</p>
 	 *
 	 * <p>When opening the editor it will also standardized the line
 	 * endings to <code>\n</code></p>
 	 *
 	 * @param file open and return an editor for this
 	 * @return <code>StructuredTextEditor</code> opened from the given <code>file</code>
 	 */
 	private StructuredTextEditor getEditor(IFile file)  {
 		StructuredTextEditor editor = (StructuredTextEditor)fFileToEditorMap.get(file);
 //		editor.getTextViewer().get

 		if(editor == null) {
 			try {
 				IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
 				IWorkbenchPage page = workbenchWindow.getActivePage();
 				IEditorPart editorPart = IDE.openEditor(page, file, true, true);
 				if(editorPart instanceof XMLMultiPageEditorPart) {
 					XMLMultiPageEditorPart xmlEditorPart = (XMLMultiPageEditorPart)editorPart;
 					editor = (StructuredTextEditor)xmlEditorPart.getAdapter(StructuredTextEditor.class);
 				} else if(editorPart instanceof StructuredTextEditor) {
 					editor = ((StructuredTextEditor)editorPart);
 				} else {
 					fail("Unable to open structured text editor: " + editorPart.getClass().getName());
 				}
 				standardizeLineEndings(editor);

 				if(editor != null) {
 					fFileToEditorMap.put(file, editor);
 				} else {
 					fail("Could not open viewer for " + file);
 				}
 			} catch (Exception e) {
 				fail("Could not open editor for " + file + " exception: " + e.getMessage());
 			}
 		}

 		return editor;
 	}

 	/**
 	 * Waits for the dirty region reconciler to finish and then verifies that only and all
 	 * of the <code>expectedPositions</code> have folding annotations in the given <code>viewer</code>
 	 *
 	 * @param viewer check for annotations at the given <code>expectedPositions</code>
 	 * in here after the dirty region reconciler job has finished
 	 * @param expectedPositions check for annotations at these positions in the given <code>viewer</code>
 	 * after the dirty region reconciler job has finished
 	 * @throws InterruptedException
 	 */
 	private void waitForReconcileThenVerify(final StructuredTextViewer viewer, final List expectedPositions) throws Exception {
 		IDocument doc = viewer.getDocument();
 		int time = 0;
 		while(doc != fReconciledDoc && time <= MAX_WAIT_TIME) {
 			Thread.sleep(WAIT_TIME);
 			time += WAIT_TIME;
 		}

 		if(doc == fReconciledDoc) {
 			verifyAnnotationPositions(viewer, expectedPositions);
 		} else {
 			Assert.fail("Document " + viewer.getDocument() + " was not reconciled with in " + MAX_WAIT_TIME +
 					" so gave up waiting and in turn could not validate folding anotations (UI blocked?)");
 		}
 	}

 	/**
 	 * Verifies that only and all of the <code>expectedPositions</code> have folding annotations
 	 * in the given <code>viewer</code>
 	 *
 	 * @param viewer check for annotations at the given <code>expectedPositions</code> in here
 	 * @param expectedPositions check for annotations at these positions in the given <code>viewer</code>
 	 */
 	private void verifyAnnotationPositions(StructuredTextViewer viewer, List expectedPositions) {
 		ProjectionAnnotationModel projectionModel = viewer.getProjectionAnnotationModel();
 		Iterator annotationIter = projectionModel.getAnnotationIterator();

 		List unexpectedPositions = new ArrayList();
 		List unexpectedAnnotations = new ArrayList();

 		while(annotationIter.hasNext()) {
 			Object obj = annotationIter.next();
 			if(obj instanceof ProjectionAnnotation) {
 				ProjectionAnnotation annotation = (ProjectionAnnotation)obj;
 				Position pos = projectionModel.getPosition(annotation);

 				boolean found = expectedPositions.remove(pos);
 				if(!found) {
 					unexpectedPositions.add(pos);
 					unexpectedAnnotations.add(annotation);
 				}

 			}
 		}

 		String error = "";
 		if(unexpectedPositions.size() != 0) {
 			error  += "There were " + unexpectedPositions.size() + " unexpected positions that were found";
 			for(int i = 0; i < unexpectedPositions.size(); ++i) {
 				error += "\n\t" + unexpectedPositions.get(i) + "\ttype:" + ((Annotation) unexpectedAnnotations.get(i)).getType();
 			}
 		}

 		if(expectedPositions.size() != 0 ) {
 			error += "\nThere were " + expectedPositions.size() + " expected positions that were not found";
 			for(int i = 0; i < expectedPositions.size(); ++i) {
 				error += "\n\t" + expectedPositions.get(i);
 			}
 		}

 		if(error.length() != 0) {
 			fail(error);
 		}
 	}

 	/**
 	 * <p>Line endings can be an issue when running tests on different OSs.
 	 * This function standardizes the line endings to use <code>\n</code></p>
 	 *
 	 * <p>It will get the text from the given editor, change the line endings,
 	 * and then save the editor</p>
 	 *
 	 * @param editor standardize the line endings of the text presented in this
 	 * editor.
 	 */
 	private void standardizeLineEndings(StructuredTextEditor editor) {
 		IDocument doc = editor.getTextViewer().getDocument();
 		String contents = doc.get();
 		contents = StringUtils.replace(contents, "\r\n", "\n");
 		contents = StringUtils.replace(contents, "\r", "\n");
 		doc.set(contents);
 	}

 	/**
 	 * <p>This inner class is used to do set up and tear down before and
 	 * after (respectively) all tests in the inclosing class have run.</p>
 	 */
 	private static class XMLCodeFoldingTestSetup extends TestSetup {
 		private static final String WTP_AUTOTEST_NONINTERACTIVE = "wtp.autotest.noninteractive";
 		private static String previousWTPAutoTestNonInteractivePropValue = null;

 		/**
 		 * Default constructor
 		 *
 		 * @param test do setup for the given test
 		 */
 		public XMLCodeFoldingTestSetup(Test test) {
 			super(test);
 		}

 		/**
 		 * <p>This is run once before all of the tests</p>
 		 *
 		 * @see junit.extensions.TestSetup#setUp()
 		 */
 		public void setUp() throws Exception {

 			initializeResources();

 			String noninteractive = System.getProperty(WTP_AUTOTEST_NONINTERACTIVE);

 			if (noninteractive != null) {
 				previousWTPAutoTestNonInteractivePropValue = noninteractive;
 			} else {
 				previousWTPAutoTestNonInteractivePropValue = "false";
 			}
 			System.setProperty(WTP_AUTOTEST_NONINTERACTIVE, "true");
 		}

 		/**
 		 * <p>This is run once after all of the tests have been run</p>
 		 *
 		 * @see junit.extensions.TestSetup#tearDown()
 		 */
 		public void tearDown() throws Exception {
 			//close out the editors
 			Iterator iter = fFileToEditorMap.values().iterator();
 			while(iter.hasNext()) {
 				StructuredTextEditor editor = (StructuredTextEditor)iter.next();
 				editor.doSave(null);
 				final IEditorPart editorPart = editor.getEditorPart();
 				editorPart.getSite().getPage().closeEditor(editorPart, false);
 			}

 			if (previousWTPAutoTestNonInteractivePropValue != null) {
 				System.setProperty(WTP_AUTOTEST_NONINTERACTIVE, previousWTPAutoTestNonInteractivePropValue);
 			}

 			fProject.delete(true, new NullProgressMonitor());
 		}

 		/**
 		 * Set up the project and workbench, this should only be done once
 		 */
 		private static void initializeResources() {
 			fProject = ProjectUtil.createProject(PROJECT_NAME, null, null);
 			ProjectUtil.copyBundleEntriesIntoWorkspace(PROJECT_FILES, PROJECT_NAME);
 		}
 	}

 	/**
 	 * ignore
 	 * @see org.eclipse.wst.sse.ui.reconcile.ISourceReconcilingListener#aboutToBeReconciled()
 	 */
 	public void aboutToBeReconciled() {
 		//ignore
 	}

 	/**
 	 * keep track of last document reconciled
 	 *
 	 * @see org.eclipse.wst.sse.ui.reconcile.ISourceReconcilingListener#reconciled(org.eclipse.jface.text.IDocument, org.eclipse.jface.text.source.IAnnotationModel, boolean, org.eclipse.core.runtime.IProgressMonitor)
 	 */
 	public void reconciled(IDocument document, IAnnotationModel model,
 			boolean forced, IProgressMonitor progressMonitor) {
 		fReconciledDoc = document;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2009, 2012 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.wst.xml.ui.tests;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import junit.extensions.TestSetup;
	import junit.framework.Assert;
	import junit.framework.Test;
	import junit.framework.TestCase;
	import junit.framework.TestSuite;

	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.jface.text.BadLocationException;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.jface.text.Position;
	import org.eclipse.jface.text.source.Annotation;
	import org.eclipse.jface.text.source.IAnnotationModel;
	import org.eclipse.jface.text.source.projection.ProjectionAnnotation;
	import org.eclipse.jface.text.source.projection.ProjectionAnnotationModel;
	import org.eclipse.ui.IEditorPart;
	import org.eclipse.ui.IWorkbenchPage;
	import org.eclipse.ui.IWorkbenchWindow;
	import org.eclipse.ui.PlatformUI;
	import org.eclipse.ui.ide.IDE;
	import org.eclipse.wst.sse.core.utils.StringUtils;
	import org.eclipse.wst.sse.ui.StructuredTextEditor;
	import org.eclipse.wst.sse.ui.internal.StructuredTextViewer;
	import org.eclipse.wst.sse.ui.reconcile.ISourceReconcilingListener;
	import org.eclipse.wst.xml.ui.internal.tabletree.XMLMultiPageEditorPart;

	/**
	* <p>Tests that code folding annotations are correctly added/removed from XML Documents</p>
	* <p>All of these tests use the same project and when possible the same open documents</p>
	*
	* @see org.eclipse.wst.xml.ui.tests.XMLCodeFoldingTest Similar Test - XML Code Folding Test
	* @see org.eclipse.wst.css.ui.tests.viewer.CSSCodeFoldingTest Similar Test - CSS Code Folding Test
	* @see org.eclipse.wst.dtd.ui.tests.viewer.DTDCodeFoldingTest Similar Test - DTD Code Folding Test
	*/
	public class XMLCodeFoldingTest extends TestCase implements ISourceReconcilingListener {
	/** max amount of time to wait for */
	private static final int MAX_WAIT_TIME = 15000;

	/** amount of time to wait for */
	private static final int WAIT_TIME = 200;

	/**
	* The name of the project that all of these tests will use
	*/
	private static final String PROJECT_NAME = "XMLCodeFoldingTest";

	/**
	* The location of the testing files
	*/
	private static final String PROJECT_FILES = "/testresources/folding";

	/**
	* The project that all of the tests use
	*/
	private static IProject fProject;

	/**
	* Used to keep track of the already open editors so that the tests don't go through
	* the trouble of opening the same editors over and over again
	*/
	private static Map fFileToEditorMap = new HashMap();

	/** the last {@link IDocument} to be reconciled */
	private static IDocument fReconciledDoc = null;

	/**
	* <p>Default constructor<p>
	* <p>Use {@link #suite()}</p>
	*
	* @see #suite()
	*/
	public XMLCodeFoldingTest() {
	super("XML Code Folding Test");
	}

	/**
	* <p>Constructor that takes a test name.</p>
	* <p>Use {@link #suite()}</p>
	*
	* @param name The name this test run should have.
	*
	* @see #suite()
	*/
	public XMLCodeFoldingTest(String name) {
	super(name);
	}

	/**
	* <p>Use this method to add these tests to a larger test suite so set up
	* and tear down can be performed</p>
	*
	* @return a {@link TestSetup} that will run all of the tests in this class
	* with set up and tear down.
	*/
	public static Test suite() {
	TestSuite ts = new TestSuite(XMLCodeFoldingTest.class, "XML Code Folding Test");
	return new XMLCodeFoldingTestSetup(ts);

	}

	/**
	* Reset the state between tests
	*
	* @see junit.framework.TestCase#setUp()
	*/
	protected void setUp() throws Exception {
	super.setUp();

	fReconciledDoc = null;
	}

	/**
	* <p><b>TEST:</b> the initially placed folding annotations</p>
	*/
	public void testInitFolding() throws Exception {
	IFile file = getFile("XMLFoldingTest1.xml");

	StructuredTextEditor editor = getEditor(file);

	// expected for single-character line delimiter
	List expectedPositions = new ArrayList();
	expectedPositions.add(new Position(142, 16));
	expectedPositions.add(new Position(173, 36));
	expectedPositions.add(new Position(39, 179));
	expectedPositions.add(new Position(71, 13));
	expectedPositions.add(new Position(62, 107));
	expectedPositions.add(new Position(47, 13));
	expectedPositions.add(new Position(87, 49));

	waitForReconcileThenVerify(editor.getTextViewer(), expectedPositions);
	}

	/**
	* <p><b>TEST:</b> that folding annotations are updated after node is removed</p>
	*/
	public void testRemoveNode() throws Exception {
	IFile file = getFile("XMLFoldingTest1.xml");

	StructuredTextEditor editor = getEditor(file);

	try {
	StructuredTextViewer viewer = editor.getTextViewer();
	IDocument doc = viewer.getDocument();
	doc.replace(87, 49, "");
	editor.doSave(null);

	final List expectedPositions = new ArrayList();
	expectedPositions.add(new Position(93, 16));
	expectedPositions.add(new Position(124, 36));
	expectedPositions.add(new Position(39, 130));
	expectedPositions.add(new Position(71, 13));
	expectedPositions.add(new Position(62, 58));
	expectedPositions.add(new Position(47, 13));

	waitForReconcileThenVerify(viewer, expectedPositions);
	} catch(BadLocationException e) {
	fail("Test is broken, replace location has become invalid.\n" + e.getMessage());
	}
	}

	/**
	* <p><b>TEST:</b> that folding annotations are updated after node is added</p>
	*/
	public void testAddNode() throws Exception {
	IFile file = getFile("XMLFoldingTest2.xml");

	StructuredTextEditor editor = getEditor(file);

	try {
	StructuredTextViewer viewer = editor.getTextViewer();
	IDocument doc = viewer.getDocument();
	doc.replace(149, 0, "\n<addMe>\n\n\n</addMe>");
	editor.doSave(null);

	List expectedPositions = new ArrayList();
	expectedPositions.add(new Position(150, 18));
	expectedPositions.add(new Position(62, 126));
	expectedPositions.add(new Position(47, 13));
	expectedPositions.add(new Position(39, 198));
	expectedPositions.add(new Position(192, 36));
	expectedPositions.add(new Position(71, 13));
	expectedPositions.add(new Position(142, 35));
	expectedPositions.add(new Position(87, 49));

	waitForReconcileThenVerify(viewer, expectedPositions);
	} catch(BadLocationException e) {
	fail("Test is broken, add location has become invalid.\n" + e.getMessage());
	}
	}

	/**
	* <p><b>TEST:</b> that even though .xsl documents do not have a specifically specified
	* folding strategy that by the power of hierarchical content types the XML folding
	* strategy is used for the XSLT document.
	*/
	public void testConfigTypeHierarchyExploration() throws Exception{
	IFile file = getFile("XSLFoldingTest1.xsl");

	StructuredTextEditor editor = getEditor(file);

	List expectedPositions = new ArrayList();
	expectedPositions.add(new Position(120, 88));
	expectedPositions.add(new Position(147, 44));
	expectedPositions.add(new Position(39, 187));

	waitForReconcileThenVerify(editor.getTextViewer(), expectedPositions);
	}

	/**
	* <p><b>TEST:</b> test the folding of comments</p>
	*/
	public void testComments() throws Exception{
	IFile file = getFile("XMLFoldingCommentTest.xml");

	StructuredTextEditor editor = getEditor(file);

	List expectedPositions = new ArrayList();
	expectedPositions.add(new Position(275, 36));
	expectedPositions.add(new Position(124, 49));
	expectedPositions.add(new Position(179, 81));
	expectedPositions.add(new Position(39, 281));
	expectedPositions.add(new Position(191, 56));
	expectedPositions.add(new Position(64, 31));
	expectedPositions.add(new Position(99, 172));
	expectedPositions.add(new Position(47, 13));
	expectedPositions.add(new Position(108, 13));

	waitForReconcileThenVerify(editor.getTextViewer(), expectedPositions);
	}

	/**
	* <p>Given a file name in <code>fProject</code> attempts to get an <code>IFile</code>
	* for it, if the file doesn't exist the test fails.</p>
	*
	* @param name the name of the file to get
	* @return the <code>IFile</code> associated with the given <code>name</code>
	*/
	private static IFile getFile(String name) {
	IFile file = fProject.getFile(name);
	assertTrue("Test file " + file + " can not be found", file.exists());

	return file;
	}

	/**
	* <p>Given a <code>file</code> get an editor for it. If an editor has already
	* been retrieved for the given <code>file</code> then return the same already
	* open editor.</p>
	*
	* <p>When opening the editor it will also standardized the line
	* endings to <code>\n</code></p>
	*
	* @param file open and return an editor for this
	* @return <code>StructuredTextEditor</code> opened from the given <code>file</code>
	*/
	private StructuredTextEditor getEditor(IFile file) {
	StructuredTextEditor editor = (StructuredTextEditor)fFileToEditorMap.get(file);
	// editor.getTextViewer().get

	if(editor == null) {
	try {
	IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
	IWorkbenchPage page = workbenchWindow.getActivePage();
	IEditorPart editorPart = IDE.openEditor(page, file, true, true);
	if(editorPart instanceof XMLMultiPageEditorPart) {
	XMLMultiPageEditorPart xmlEditorPart = (XMLMultiPageEditorPart)editorPart;
	editor = (StructuredTextEditor)xmlEditorPart.getAdapter(StructuredTextEditor.class);
	} else if(editorPart instanceof StructuredTextEditor) {
	editor = ((StructuredTextEditor)editorPart);
	} else {
	fail("Unable to open structured text editor: " + editorPart.getClass().getName());
	}
	standardizeLineEndings(editor);

	if(editor != null) {
	fFileToEditorMap.put(file, editor);
	} else {
	fail("Could not open viewer for " + file);
	}
	} catch (Exception e) {
	fail("Could not open editor for " + file + " exception: " + e.getMessage());
	}
	}

	return editor;
	}

	/**
	* Waits for the dirty region reconciler to finish and then verifies that only and all
	* of the <code>expectedPositions</code> have folding annotations in the given <code>viewer</code>
	*
	* @param viewer check for annotations at the given <code>expectedPositions</code>
	* in here after the dirty region reconciler job has finished
	* @param expectedPositions check for annotations at these positions in the given <code>viewer</code>
	* after the dirty region reconciler job has finished
	* @throws InterruptedException
	*/
	private void waitForReconcileThenVerify(final StructuredTextViewer viewer, final List expectedPositions) throws Exception {
	IDocument doc = viewer.getDocument();
	int time = 0;
	while(doc != fReconciledDoc && time <= MAX_WAIT_TIME) {
	Thread.sleep(WAIT_TIME);
	time += WAIT_TIME;
	}

	if(doc == fReconciledDoc) {
	verifyAnnotationPositions(viewer, expectedPositions);
	} else {
	Assert.fail("Document " + viewer.getDocument() + " was not reconciled with in " + MAX_WAIT_TIME +
	" so gave up waiting and in turn could not validate folding anotations (UI blocked?)");
	}
	}

	/**
	* Verifies that only and all of the <code>expectedPositions</code> have folding annotations
	* in the given <code>viewer</code>
	*
	* @param viewer check for annotations at the given <code>expectedPositions</code> in here
	* @param expectedPositions check for annotations at these positions in the given <code>viewer</code>
	*/
	private void verifyAnnotationPositions(StructuredTextViewer viewer, List expectedPositions) {
	ProjectionAnnotationModel projectionModel = viewer.getProjectionAnnotationModel();
	Iterator annotationIter = projectionModel.getAnnotationIterator();

	List unexpectedPositions = new ArrayList();
	List unexpectedAnnotations = new ArrayList();

	while(annotationIter.hasNext()) {
	Object obj = annotationIter.next();
	if(obj instanceof ProjectionAnnotation) {
	ProjectionAnnotation annotation = (ProjectionAnnotation)obj;
	Position pos = projectionModel.getPosition(annotation);

	boolean found = expectedPositions.remove(pos);
	if(!found) {
	unexpectedPositions.add(pos);
	unexpectedAnnotations.add(annotation);
	}

	}
	}

	String error = "";
	if(unexpectedPositions.size() != 0) {
	error += "There were " + unexpectedPositions.size() + " unexpected positions that were found";
	for(int i = 0; i < unexpectedPositions.size(); ++i) {
	error += "\n\t" + unexpectedPositions.get(i) + "\ttype:" + ((Annotation) unexpectedAnnotations.get(i)).getType();
	}
	}

	if(expectedPositions.size() != 0 ) {
	error += "\nThere were " + expectedPositions.size() + " expected positions that were not found";
	for(int i = 0; i < expectedPositions.size(); ++i) {
	error += "\n\t" + expectedPositions.get(i);
	}
	}

	if(error.length() != 0) {
	fail(error);
	}
	}

	/**
	* <p>Line endings can be an issue when running tests on different OSs.
	* This function standardizes the line endings to use <code>\n</code></p>
	*
	* <p>It will get the text from the given editor, change the line endings,
	* and then save the editor</p>
	*
	* @param editor standardize the line endings of the text presented in this
	* editor.
	*/
	private void standardizeLineEndings(StructuredTextEditor editor) {
	IDocument doc = editor.getTextViewer().getDocument();
	String contents = doc.get();
	contents = StringUtils.replace(contents, "\r\n", "\n");
	contents = StringUtils.replace(contents, "\r", "\n");
	doc.set(contents);
	}

	/**
	* <p>This inner class is used to do set up and tear down before and
	* after (respectively) all tests in the inclosing class have run.</p>
	*/
	private static class XMLCodeFoldingTestSetup extends TestSetup {
	private static final String WTP_AUTOTEST_NONINTERACTIVE = "wtp.autotest.noninteractive";
	private static String previousWTPAutoTestNonInteractivePropValue = null;

	/**
	* Default constructor
	*
	* @param test do setup for the given test
	*/
	public XMLCodeFoldingTestSetup(Test test) {
	super(test);
	}

	/**
	* <p>This is run once before all of the tests</p>
	*
	* @see junit.extensions.TestSetup#setUp()
	*/
	public void setUp() throws Exception {

	initializeResources();

	String noninteractive = System.getProperty(WTP_AUTOTEST_NONINTERACTIVE);

	if (noninteractive != null) {
	previousWTPAutoTestNonInteractivePropValue = noninteractive;
	} else {
	previousWTPAutoTestNonInteractivePropValue = "false";
	}
	System.setProperty(WTP_AUTOTEST_NONINTERACTIVE, "true");
	}

	/**
	* <p>This is run once after all of the tests have been run</p>
	*
	* @see junit.extensions.TestSetup#tearDown()
	*/
	public void tearDown() throws Exception {
	//close out the editors
	Iterator iter = fFileToEditorMap.values().iterator();
	while(iter.hasNext()) {
	StructuredTextEditor editor = (StructuredTextEditor)iter.next();
	editor.doSave(null);
	final IEditorPart editorPart = editor.getEditorPart();
	editorPart.getSite().getPage().closeEditor(editorPart, false);
	}

	if (previousWTPAutoTestNonInteractivePropValue != null) {
	System.setProperty(WTP_AUTOTEST_NONINTERACTIVE, previousWTPAutoTestNonInteractivePropValue);
	}

	fProject.delete(true, new NullProgressMonitor());
	}

	/**
	* Set up the project and workbench, this should only be done once
	*/
	private static void initializeResources() {
	fProject = ProjectUtil.createProject(PROJECT_NAME, null, null);
	ProjectUtil.copyBundleEntriesIntoWorkspace(PROJECT_FILES, PROJECT_NAME);
	}
	}

	/**
	* ignore
	* @see org.eclipse.wst.sse.ui.reconcile.ISourceReconcilingListener#aboutToBeReconciled()
	*/
	public void aboutToBeReconciled() {
	//ignore
	}

	/**
	* keep track of last document reconciled
	*
	* @see org.eclipse.wst.sse.ui.reconcile.ISourceReconcilingListener#reconciled(org.eclipse.jface.text.IDocument, org.eclipse.jface.text.source.IAnnotationModel, boolean, org.eclipse.core.runtime.IProgressMonitor)
	*/
	public void reconciled(IDocument document, IAnnotationModel model,
	boolean forced, IProgressMonitor progressMonitor) {
	fReconciledDoc = document;
	}
	}