tests/org.eclipse.jst.jsp.ui.tests/jface.text.tests/org/eclipse/jface/text/tests/AbstractUndoManagerTest.java - sourceediting/webtools.sourceediting.tests - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2008 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.jface.text.tests;

 import junit.framework.TestCase;

 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.IDocumentExtension4;
 import org.eclipse.jface.text.ITextViewer;
 import org.eclipse.jface.text.IUndoManager;
 import org.eclipse.jface.text.Position;
 import org.eclipse.jface.text.TextViewer;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.wst.sse.core.internal.ltk.modelhandler.IModelHandler;
 import org.eclipse.wst.sse.core.internal.modelhandler.ModelHandlerRegistry;
 import org.eclipse.wst.sse.core.internal.text.BasicStructuredDocument;

 /**
  * Tests for DefaultUndoManager. Changed from the JFace original to creates
  * and test against a structured document.
  */
 public abstract class AbstractUndoManagerTest extends TestCase {

 	/** The maximum undo level. */
 	private static final int MAX_UNDO_LEVEL= 256;

 	/** The shell. */
 	private Shell fShell;
 	/** The text viewer. */
 	private ITextViewer fTextViewer;
 	/** The undo manager. */
 	private IUndoManager fUndoManager;

 	private static final int LOOP_COUNT= 20;

 	//--- Static data sets for comparing scenarios - obtained from capturing random data ---
 	/** Original document */
 	private static final String INITIAL_DOCUMENT_CONTENT= "+7cyg:/F!T4KnW;0+au$t1G%(`Z|u'7'_!-k?<c\"2Y.]CwsO.r";
 	/** Replacement string */
 	private static final String [] REPLACEMENTS= { ">", "F", "M/r-*", "-", "bl", "", "}%/#", "", "k&", "f", "\\g", "c!x", "TLG-", "NPO", "Rp9u", "", "X", "W(", ")z", "oe", "", "h*", "t", "I", "X=N>", "2yt", "&Z", "2)W=", ":K", "P9S", "s8t8o", "", "", "5{7", "%", "", "v3", "Wz", "sH", "3c", "8", "ol", ",6$", "94[#", ".~", "n", ">", "9", "W", ",(FW", "Q", "^", "Bq", "$", "re", "", "9", "8[", "Mx", "4b", "$6", "F", "8s]", "o", "-", "E&6", "S\\", "/", "z.a", "4ai", "b", ")", "", "l", "VU", "7M+Ql", "xZ?x", "xx", "lc", "b", "A", "!", "4pSU", "", "{J", "H", "l>_", "n&9", "", "&`", ";igQxq", "", ">", ";\"", "k\\`]G", "o{?", "", "K", "_6", "="};
 	/** Position/offset pairs */
 	private static final int [] POSITIONS= { 18, 2, 43, 1, 3, 2, 28, 3, 35, 1, 23, 5, 32, 2, 30, 1, 22, 1, 37, 0, 23, 3, 43, 2, 46, 1, 17, 1, 36, 6, 17, 5, 30, 4, 25, 1, 2, 2, 30, 0, 37, 3, 28, 1, 30, 2, 20, 5, 33, 1, 29, 1, 15, 2, 21, 2, 24, 4, 38, 3, 8, 0, 33, 2, 15, 2, 25, 0, 8, 2, 20, 3, 43, 2, 44, 1, 44, 2, 32, 2, 40, 2, 32, 3, 12, 2, 38, 3, 33, 2, 46, 0, 13, 3, 45, 0, 16, 2, 3, 2, 44, 0, 48, 0, 18, 5, 7, 6, 7, 3, 40, 0, 9, 1, 16, 3, 28, 3, 36, 1, 35, 2, 0, 3, 6, 1, 10, 4, 14, 2, 15, 3, 33, 1, 36, 0, 37, 0, 4, 3, 31, 3, 33, 3, 11, 3, 20, 2, 25, 3, 4, 3, 7, 3, 17, 0, 3, 1, 31, 3, 34, 1, 21, 0, 33, 1, 17, 4, 9, 1, 26, 3, 2, 3, 12, 1, 26, 3, 9, 5, 5, 0, 31, 3, 0, 3, 12, 1, 1, 1, 3, 0, 39, 0, 9, 2, 2, 0, 28, 2};

 	private static final boolean DEBUG= false;


 	/*
 	 * @see TestCase#TestCase(String)
 	 */
 	public AbstractUndoManagerTest(final String name) {
 		super(name);
 	}

 	/*
 	 *  @see TestCase#setUp()
 	 */
 	protected void setUp() {
 		fShell= new Shell();
 		fUndoManager= createUndoManager(MAX_UNDO_LEVEL);
 		fTextViewer= new TextViewer(fShell, SWT.NONE);
 		fTextViewer.setUndoManager(fUndoManager);
 		fUndoManager.connect(fTextViewer);
 	}

 	abstract protected IUndoManager createUndoManager(int maxUndoLevel);

 	/*
 	 *  @see TestCase#tearDown()
 	 */
 	protected void tearDown() {
 		fUndoManager.disconnect();
 		fUndoManager= null;
 		fShell.dispose();
 		fShell= null;
 		fTextViewer= null;
 	}

 	/**
 	 * Test for line delimiter conversion.
 	 */
 	public void testConvertLineDelimiters() {
 		final String original= "a\r\nb\r\n";
 		final IDocument document= createDocument(original);
 		fTextViewer.setDocument(document);

 		try {
 			document.replace(1, 2, "\n");
 			document.replace(3, 2, "\n");
 		} catch (BadLocationException e) {
 			assertTrue(false);
 		}

 		assertTrue(fUndoManager.undoable());
 		fUndoManager.undo();
 		assertTrue(fUndoManager.undoable());
 		fUndoManager.undo();

 		final String reverted= document.get();

 		assertEquals(original, reverted);
 	}

 	/**
 	 * Randomly applies document changes.
 	 */
 	public void testRandomAccess() {
 		final int RANDOM_STRING_LENGTH= 50;
 		final int RANDOM_REPLACE_COUNT= 100;

 		assertTrue(RANDOM_REPLACE_COUNT >= 1);
 		assertTrue(RANDOM_REPLACE_COUNT <= MAX_UNDO_LEVEL);

 		String original= createRandomString(RANDOM_STRING_LENGTH);
 		final IDocument document= createDocument(original);
 		fTextViewer.setDocument(document);

 		doChange(document, RANDOM_REPLACE_COUNT);

 		assertTrue(fUndoManager.undoable());
 		while (fUndoManager.undoable())
 			fUndoManager.undo();

 		final String reverted= document.get();
 		assertEquals(original, reverted);
 	}

 	private void doChange(IDocument document, int count) {
 		try {
 			String before= document.get();

 			if (DEBUG)
 				System.out.println(before);

 			Position [] positions= new Position[count];
 			String [] strings= new String[count];
 			for (int i= 0; i < count; i++) {
 				final Position position= createRandomPositionPoisson(document.getLength());
 				final String string= createRandomStringPoisson();
 				document.replace(position.getOffset(), position.getLength(), string);
 				positions[i]= position;
 				strings[i]= string;
 			}

 			if (DEBUG) {
 				System.out.print("{ ");
 				for (int i=0; i<count; i++) {
 					System.out.print(positions[i].getOffset());
 					System.out.print(", ");
 					System.out.print(positions[i].getLength());
 					System.out.print(", ");
 				}
 				System.out.println(" }");
 				System.out.print("{ ");
 				for (int i=0; i<count; i++) {
 					System.out.print("\"");
 					System.out.print(strings[i]);
 					System.out.print("\", ");
 				}
 				System.out.println(" }");
 			}
 		} catch (BadLocationException e) {
 			assertTrue(false);
 		}
 	}

 	// repeatable test case for comparing success/failure among different tests
 	private void doRepeatableChange(IDocument document) {
 		assertTrue(POSITIONS.length >= (2 * REPLACEMENTS.length));
 		try {
 			for (int i= 0; i < REPLACEMENTS.length; i++) {
 				int offset= POSITIONS[i*2];
 				int length= POSITIONS[i*2+1];
 				if (document.getLength() > offset + length)
 					document.replace(offset, length, REPLACEMENTS[i]);
 				else
 					document.replace(0,0, REPLACEMENTS[i]);
 			}
 		} catch (BadLocationException e) {
 			assertTrue(false);
 		}
 	}

 	public void testLoopRandomAccessAsCompound() {
 		int i= 0;
 		while (i < LOOP_COUNT) {
 			fUndoManager.reset();
 			testRandomAccessAsCompound();
 			i++;
 		}
 	}

 	public void testLoopRandomAccess() {
 		int i= 0;
 		while (i < LOOP_COUNT) {
 			fUndoManager.reset();
 			testRandomAccess();
 			i++;
 		}
 	}

 	public void testLoopRandomAccessAsUnclosedCompound() {
 		int i= 0;
 		while (i < LOOP_COUNT) {
 			fUndoManager.reset();
 			testRandomAccessAsUnclosedCompound();
 			i++;
 		}
 	}

 	public void testLoopConvertLineDelimiters() {
 		int i= 0;
 		while (i < LOOP_COUNT) {
 			fUndoManager.reset();
 			testConvertLineDelimiters();
 			i++;
 		}
 	}

 	public void testLoopRandomAccessWithMixedCompound() {
 		int i= 0;
 		while (i < LOOP_COUNT) {
 			fUndoManager.reset();
 			testRandomAccessWithMixedCompound();
 			i++;
 		}
 	}

 	public void testRandomAccessAsCompound() {
 		final int RANDOM_STRING_LENGTH= 50;
 		final int RANDOM_REPLACE_COUNT= 100;

 		assertTrue(RANDOM_REPLACE_COUNT >= 1);
 		assertTrue(RANDOM_REPLACE_COUNT <= MAX_UNDO_LEVEL);

 		String original= createRandomString(RANDOM_STRING_LENGTH);
 		final IDocument document= createDocument(original);
 		fTextViewer.setDocument(document);

 		fUndoManager.beginCompoundChange();
 		doChange(document, RANDOM_REPLACE_COUNT);
 		fUndoManager.endCompoundChange();

 		assertTrue(fUndoManager.undoable());
 		while (fUndoManager.undoable())
 			fUndoManager.undo();
 		assertTrue(!fUndoManager.undoable());

 		final String reverted= document.get();

 		assertEquals(original, reverted);
 	}

 	/**
 	 * Test case for https://bugs.eclipse.org/bugs/show_bug.cgi?id=88172
 	 */
 	public void testRandomAccessAsUnclosedCompound() {

 		final int RANDOM_STRING_LENGTH= 50;
 		final int RANDOM_REPLACE_COUNT= 100;

 		assertTrue(RANDOM_REPLACE_COUNT >= 1);
 		assertTrue(RANDOM_REPLACE_COUNT <= MAX_UNDO_LEVEL);

 		String original= createRandomString(RANDOM_STRING_LENGTH);
 		final IDocument document= createDocument(original);
 		fTextViewer.setDocument(document);

 		fUndoManager.beginCompoundChange();
 		doChange(document, RANDOM_REPLACE_COUNT);
 		// do not close the compound.
 		// fUndoManager.endCompoundChange();

 		assertTrue(fUndoManager.undoable());
 		while (fUndoManager.undoable())
 			fUndoManager.undo();
 		assertTrue(!fUndoManager.undoable());

 		final String reverted= document.get();

 		assertEquals(original, reverted);
 	}

 	public void testRandomAccessWithMixedCompound() {

 		final int RANDOM_STRING_LENGTH= 50;
 		final int RANDOM_REPLACE_COUNT= 10;
 		final int NUMBER_COMPOUNDS= 5;
 		final int NUMBER_ATOMIC_PER_COMPOUND= 3;

 		assertTrue(RANDOM_REPLACE_COUNT >= 1);
 		assertTrue(NUMBER_COMPOUNDS * (1 + NUMBER_ATOMIC_PER_COMPOUND) * RANDOM_REPLACE_COUNT <= MAX_UNDO_LEVEL);

 		String original= createRandomString(RANDOM_STRING_LENGTH);
 		final IDocument document= createDocument(original);
 		fTextViewer.setDocument(document);

 		for (int i= 0; i < NUMBER_COMPOUNDS; i++) {
 			fUndoManager.beginCompoundChange();
 			doChange(document, RANDOM_REPLACE_COUNT);
 			fUndoManager.endCompoundChange();
 			assertTrue(fUndoManager.undoable());
 			for (int j= 0; j < NUMBER_ATOMIC_PER_COMPOUND; j++) {
 				doChange(document, RANDOM_REPLACE_COUNT);
 				assertTrue(fUndoManager.undoable());
 			}
 		}

 		assertTrue(fUndoManager.undoable());
 		while (fUndoManager.undoable())
 			fUndoManager.undo();
 		assertTrue(!fUndoManager.undoable());

 		final String reverted= document.get();

 		assertEquals(original, reverted);
 	}

 	public void testRepeatableAccess() {
 		assertTrue(REPLACEMENTS.length <= MAX_UNDO_LEVEL);

 		final IDocument document= createDocument(INITIAL_DOCUMENT_CONTENT);
 		fTextViewer.setDocument(document);

 		doRepeatableChange(document);

 		assertTrue(fUndoManager.undoable());
 		while (fUndoManager.undoable())
 			fUndoManager.undo();

 		final String reverted= document.get();

 		assertEquals(INITIAL_DOCUMENT_CONTENT, reverted);
 	}

 	public void testRepeatableAccessAsCompound() {
 		assertTrue(REPLACEMENTS.length <= MAX_UNDO_LEVEL);

 		final IDocument document= createDocument(INITIAL_DOCUMENT_CONTENT);
 		fTextViewer.setDocument(document);

 		fUndoManager.beginCompoundChange();
 		doRepeatableChange(document);
 		fUndoManager.endCompoundChange();

 		assertTrue(fUndoManager.undoable());
 		fUndoManager.undo();
 		// with a single compound, there should be only one undo
 		assertFalse(fUndoManager.undoable());

 		final String reverted= document.get();

 		assertEquals(INITIAL_DOCUMENT_CONTENT, reverted);
 	}

 	public void testRepeatableAccessAsUnclosedCompound() {
 		assertTrue(REPLACEMENTS.length <= MAX_UNDO_LEVEL);

 		final IDocument document= createDocument(INITIAL_DOCUMENT_CONTENT);
 		fTextViewer.setDocument(document);

 		fUndoManager.beginCompoundChange();
 		doRepeatableChange(document);

 		assertTrue(fUndoManager.undoable());
 		while (fUndoManager.undoable())
 			fUndoManager.undo();

 		final String reverted= document.get();

 		assertEquals(INITIAL_DOCUMENT_CONTENT, reverted);
 	}

 	public void testRepeatableAccessWithMixedAndEmptyCompound() {
 		assertTrue(REPLACEMENTS.length + 2 <= MAX_UNDO_LEVEL);

 		final IDocument document= createDocument(INITIAL_DOCUMENT_CONTENT);
 		fTextViewer.setDocument(document);

 		fUndoManager.beginCompoundChange();
 		doRepeatableChange(document);
 		fUndoManager.endCompoundChange();
 		assertTrue(fUndoManager.undoable());

 		// insert an empty compound
 		fUndoManager.beginCompoundChange();
 		fUndoManager.endCompoundChange();

 	    // insert the atomic changes
 		doRepeatableChange(document);

 		assertTrue(fUndoManager.undoable());
 		while (fUndoManager.undoable())
 			fUndoManager.undo();
 		assertTrue(!fUndoManager.undoable());

 		final String reverted= document.get();

 		assertEquals(INITIAL_DOCUMENT_CONTENT, reverted);
 	}

 	public void testDocumentStamp() {
 		final IDocument document= createDocument(INITIAL_DOCUMENT_CONTENT);
 		fTextViewer.setDocument(document);
 		long stamp= ((IDocumentExtension4)document).getModificationStamp();
 		doChange(document, 1);
 		fUndoManager.undo();
 		assertEquals(stamp, ((IDocumentExtension4)document).getModificationStamp());

 	}

 	// see: https://bugs.eclipse.org/bugs/show_bug.cgi?id=109104
 	public void testDocumentStamp2() throws BadLocationException {
 		final IDocument document= createDocument("");
 		final int stringLength= 13;
 		fTextViewer.setDocument(document);
 		document.replace(0, 0, createRandomString(stringLength));
 		long stamp= ((IDocumentExtension4)document).getModificationStamp();
 		fUndoManager.undo();
 		document.replace(0, 0, createRandomString(stringLength));
 		assertFalse(stamp == ((IDocumentExtension4)document).getModificationStamp());

 	}

 	private static String createRandomString(int length) {
 		final StringBuffer buffer= new StringBuffer();

 		for (int i= 0; i < length; i++)
 			buffer.append(getRandomCharacter());

 		return buffer.toString();
 	}

 	private static final char getRandomCharacter() {
 		// XXX should include \t
 		return (char) (32 + 95 * Math.random());
 	}

 	private static String createRandomStringPoisson() {
 		final int length= getRandomPoissonValue(2);
 		return createRandomString(length);
 	}

 	private IDocument createDocument(String contents) {
 		IModelHandler handler = ModelHandlerRegistry.getInstance().getHandlerForContentTypeId("org.eclipse.core.runtime.xml");
 		BasicStructuredDocument document = (BasicStructuredDocument) handler.getDocumentLoader().createNewStructuredDocument();
 		document.set(contents);
 //		return new Document(contents);
 		return document;
 	}

 	private static Position createRandomPositionPoisson(int documentLength) {

 		float random= (float) Math.random();
 		int offset= (int) (random * (documentLength + 1));

 		// Catch potential rounding issue
 		if (offset == documentLength + 1)
 			offset= documentLength;

 		int length= getRandomPoissonValue(2);
 		if (offset + length > documentLength)
 			length= documentLength - offset;

 		return new Position(offset, length);
 	}

 	private static int getRandomPoissonValue(int mean) {
 		final int MAX_VALUE= 10;

 		final float random= (float) Math.random();
 		float probability= 0;
 		int i= 0;
 		while (probability < 1 && i < MAX_VALUE) {
 			probability += getPoissonDistribution(mean, i);
 			if (random <= probability)
 				break;
 			i++;
 		}
 		return i;
 	}

 	private static float getPoissonDistribution(float lambda, int k) {
 		return (float) (Math.exp(-lambda) * Math.pow(lambda, k) / faculty(k));
 	}

 	/**
 	 * Returns the faculty of k.
 	 *
 	 * @param k the <code>int</code> for which to get the faculty
 	 * @return the faculty
 	 */
 	private static final int faculty(int k) {
 		return k == 0
 			? 1
 			: k * faculty(k - 1);
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2000, 2008 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.jface.text.tests;

	import junit.framework.TestCase;

	import org.eclipse.jface.text.BadLocationException;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.jface.text.IDocumentExtension4;
	import org.eclipse.jface.text.ITextViewer;
	import org.eclipse.jface.text.IUndoManager;
	import org.eclipse.jface.text.Position;
	import org.eclipse.jface.text.TextViewer;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.widgets.Shell;
	import org.eclipse.wst.sse.core.internal.ltk.modelhandler.IModelHandler;
	import org.eclipse.wst.sse.core.internal.modelhandler.ModelHandlerRegistry;
	import org.eclipse.wst.sse.core.internal.text.BasicStructuredDocument;

	/**
	* Tests for DefaultUndoManager. Changed from the JFace original to creates
	* and test against a structured document.
	*/
	public abstract class AbstractUndoManagerTest extends TestCase {

	/** The maximum undo level. */
	private static final int MAX_UNDO_LEVEL= 256;

	/** The shell. */
	private Shell fShell;
	/** The text viewer. */
	private ITextViewer fTextViewer;
	/** The undo manager. */
	private IUndoManager fUndoManager;

	private static final int LOOP_COUNT= 20;

	//--- Static data sets for comparing scenarios - obtained from capturing random data ---
	/** Original document */
	private static final String INITIAL_DOCUMENT_CONTENT= "+7cyg:/F!T4KnW;0+au$t1G%(`Z\|u'7'_!-k?<c\"2Y.]CwsO.r";
	/** Replacement string */
	private static final String [] REPLACEMENTS= { ">", "F", "M/r-", "-", "bl", "", "}%/#", "", "k&", "f", "\\g", "c!x", "TLG-", "NPO", "Rp9u", "", "X", "W(", ")z", "oe", "", "h", "t", "I", "X=N>", "2yt", "&Z", "2)W=", ":K", "P9S", "s8t8o", "", "", "5{7", "%", "", "v3", "Wz", "sH", "3c", "8", "ol", ",6$", "94[#", ".~", "n", ">", "9", "W", ",(FW", "Q", "^", "Bq", "$", "re", "", "9", "8[", "Mx", "4b", "$6", "F", "8s]", "o", "-", "E&6", "S\\", "/", "z.a", "4ai", "b", ")", "", "l", "VU", "7M+Ql", "xZ?x", "xx", "lc", "b", "A", "!", "4pSU", "", "{J", "H", "l>_", "n&9", "", "&`", ";igQxq", "", ">", ";\"", "k\\`]G", "o{?", "", "K", "_6", "="};
	/** Position/offset pairs */
	private static final int [] POSITIONS= { 18, 2, 43, 1, 3, 2, 28, 3, 35, 1, 23, 5, 32, 2, 30, 1, 22, 1, 37, 0, 23, 3, 43, 2, 46, 1, 17, 1, 36, 6, 17, 5, 30, 4, 25, 1, 2, 2, 30, 0, 37, 3, 28, 1, 30, 2, 20, 5, 33, 1, 29, 1, 15, 2, 21, 2, 24, 4, 38, 3, 8, 0, 33, 2, 15, 2, 25, 0, 8, 2, 20, 3, 43, 2, 44, 1, 44, 2, 32, 2, 40, 2, 32, 3, 12, 2, 38, 3, 33, 2, 46, 0, 13, 3, 45, 0, 16, 2, 3, 2, 44, 0, 48, 0, 18, 5, 7, 6, 7, 3, 40, 0, 9, 1, 16, 3, 28, 3, 36, 1, 35, 2, 0, 3, 6, 1, 10, 4, 14, 2, 15, 3, 33, 1, 36, 0, 37, 0, 4, 3, 31, 3, 33, 3, 11, 3, 20, 2, 25, 3, 4, 3, 7, 3, 17, 0, 3, 1, 31, 3, 34, 1, 21, 0, 33, 1, 17, 4, 9, 1, 26, 3, 2, 3, 12, 1, 26, 3, 9, 5, 5, 0, 31, 3, 0, 3, 12, 1, 1, 1, 3, 0, 39, 0, 9, 2, 2, 0, 28, 2};

	private static final boolean DEBUG= false;


	/*
	* @see TestCase#TestCase(String)
	*/
	public AbstractUndoManagerTest(final String name) {
	super(name);
	}

	/*
	* @see TestCase#setUp()
	*/
	protected void setUp() {
	fShell= new Shell();
	fUndoManager= createUndoManager(MAX_UNDO_LEVEL);
	fTextViewer= new TextViewer(fShell, SWT.NONE);
	fTextViewer.setUndoManager(fUndoManager);
	fUndoManager.connect(fTextViewer);
	}

	abstract protected IUndoManager createUndoManager(int maxUndoLevel);

	/*
	* @see TestCase#tearDown()
	*/
	protected void tearDown() {
	fUndoManager.disconnect();
	fUndoManager= null;
	fShell.dispose();
	fShell= null;
	fTextViewer= null;
	}

	/**
	* Test for line delimiter conversion.
	*/
	public void testConvertLineDelimiters() {
	final String original= "a\r\nb\r\n";
	final IDocument document= createDocument(original);
	fTextViewer.setDocument(document);

	try {
	document.replace(1, 2, "\n");
	document.replace(3, 2, "\n");
	} catch (BadLocationException e) {
	assertTrue(false);
	}

	assertTrue(fUndoManager.undoable());
	fUndoManager.undo();
	assertTrue(fUndoManager.undoable());
	fUndoManager.undo();

	final String reverted= document.get();

	assertEquals(original, reverted);
	}

	/**
	* Randomly applies document changes.
	*/
	public void testRandomAccess() {
	final int RANDOM_STRING_LENGTH= 50;
	final int RANDOM_REPLACE_COUNT= 100;

	assertTrue(RANDOM_REPLACE_COUNT >= 1);
	assertTrue(RANDOM_REPLACE_COUNT <= MAX_UNDO_LEVEL);

	String original= createRandomString(RANDOM_STRING_LENGTH);
	final IDocument document= createDocument(original);
	fTextViewer.setDocument(document);

	doChange(document, RANDOM_REPLACE_COUNT);

	assertTrue(fUndoManager.undoable());
	while (fUndoManager.undoable())
	fUndoManager.undo();

	final String reverted= document.get();
	assertEquals(original, reverted);
	}

	private void doChange(IDocument document, int count) {
	try {
	String before= document.get();

	if (DEBUG)
	System.out.println(before);

	Position [] positions= new Position[count];
	String [] strings= new String[count];
	for (int i= 0; i < count; i++) {
	final Position position= createRandomPositionPoisson(document.getLength());
	final String string= createRandomStringPoisson();
	document.replace(position.getOffset(), position.getLength(), string);
	positions[i]= position;
	strings[i]= string;
	}

	if (DEBUG) {
	System.out.print("{ ");
	for (int i=0; i<count; i++) {
	System.out.print(positions[i].getOffset());
	System.out.print(", ");
	System.out.print(positions[i].getLength());
	System.out.print(", ");
	}
	System.out.println(" }");
	System.out.print("{ ");
	for (int i=0; i<count; i++) {
	System.out.print("\"");
	System.out.print(strings[i]);
	System.out.print("\", ");
	}
	System.out.println(" }");
	}
	} catch (BadLocationException e) {
	assertTrue(false);
	}
	}

	// repeatable test case for comparing success/failure among different tests
	private void doRepeatableChange(IDocument document) {
	assertTrue(POSITIONS.length >= (2 * REPLACEMENTS.length));
	try {
	for (int i= 0; i < REPLACEMENTS.length; i++) {
	int offset= POSITIONS[i*2];
	int length= POSITIONS[i*2+1];
	if (document.getLength() > offset + length)
	document.replace(offset, length, REPLACEMENTS[i]);
	else
	document.replace(0,0, REPLACEMENTS[i]);
	}
	} catch (BadLocationException e) {
	assertTrue(false);
	}
	}

	public void testLoopRandomAccessAsCompound() {
	int i= 0;
	while (i < LOOP_COUNT) {
	fUndoManager.reset();
	testRandomAccessAsCompound();
	i++;
	}
	}

	public void testLoopRandomAccess() {
	int i= 0;
	while (i < LOOP_COUNT) {
	fUndoManager.reset();
	testRandomAccess();
	i++;
	}
	}

	public void testLoopRandomAccessAsUnclosedCompound() {
	int i= 0;
	while (i < LOOP_COUNT) {
	fUndoManager.reset();
	testRandomAccessAsUnclosedCompound();
	i++;
	}
	}

	public void testLoopConvertLineDelimiters() {
	int i= 0;
	while (i < LOOP_COUNT) {
	fUndoManager.reset();
	testConvertLineDelimiters();
	i++;
	}
	}

	public void testLoopRandomAccessWithMixedCompound() {
	int i= 0;
	while (i < LOOP_COUNT) {
	fUndoManager.reset();
	testRandomAccessWithMixedCompound();
	i++;
	}
	}

	public void testRandomAccessAsCompound() {
	final int RANDOM_STRING_LENGTH= 50;
	final int RANDOM_REPLACE_COUNT= 100;

	assertTrue(RANDOM_REPLACE_COUNT >= 1);
	assertTrue(RANDOM_REPLACE_COUNT <= MAX_UNDO_LEVEL);

	String original= createRandomString(RANDOM_STRING_LENGTH);
	final IDocument document= createDocument(original);
	fTextViewer.setDocument(document);

	fUndoManager.beginCompoundChange();
	doChange(document, RANDOM_REPLACE_COUNT);
	fUndoManager.endCompoundChange();

	assertTrue(fUndoManager.undoable());
	while (fUndoManager.undoable())
	fUndoManager.undo();
	assertTrue(!fUndoManager.undoable());

	final String reverted= document.get();

	assertEquals(original, reverted);
	}

	/**
	* Test case for https://bugs.eclipse.org/bugs/show_bug.cgi?id=88172
	*/
	public void testRandomAccessAsUnclosedCompound() {

	final int RANDOM_STRING_LENGTH= 50;
	final int RANDOM_REPLACE_COUNT= 100;

	assertTrue(RANDOM_REPLACE_COUNT >= 1);
	assertTrue(RANDOM_REPLACE_COUNT <= MAX_UNDO_LEVEL);

	String original= createRandomString(RANDOM_STRING_LENGTH);
	final IDocument document= createDocument(original);
	fTextViewer.setDocument(document);

	fUndoManager.beginCompoundChange();
	doChange(document, RANDOM_REPLACE_COUNT);
	// do not close the compound.
	// fUndoManager.endCompoundChange();

	assertTrue(fUndoManager.undoable());
	while (fUndoManager.undoable())
	fUndoManager.undo();
	assertTrue(!fUndoManager.undoable());

	final String reverted= document.get();

	assertEquals(original, reverted);
	}

	public void testRandomAccessWithMixedCompound() {

	final int RANDOM_STRING_LENGTH= 50;
	final int RANDOM_REPLACE_COUNT= 10;
	final int NUMBER_COMPOUNDS= 5;
	final int NUMBER_ATOMIC_PER_COMPOUND= 3;

	assertTrue(RANDOM_REPLACE_COUNT >= 1);
	assertTrue(NUMBER_COMPOUNDS * (1 + NUMBER_ATOMIC_PER_COMPOUND) * RANDOM_REPLACE_COUNT <= MAX_UNDO_LEVEL);

	String original= createRandomString(RANDOM_STRING_LENGTH);
	final IDocument document= createDocument(original);
	fTextViewer.setDocument(document);

	for (int i= 0; i < NUMBER_COMPOUNDS; i++) {
	fUndoManager.beginCompoundChange();
	doChange(document, RANDOM_REPLACE_COUNT);
	fUndoManager.endCompoundChange();
	assertTrue(fUndoManager.undoable());
	for (int j= 0; j < NUMBER_ATOMIC_PER_COMPOUND; j++) {
	doChange(document, RANDOM_REPLACE_COUNT);
	assertTrue(fUndoManager.undoable());
	}
	}

	assertTrue(fUndoManager.undoable());
	while (fUndoManager.undoable())
	fUndoManager.undo();
	assertTrue(!fUndoManager.undoable());

	final String reverted= document.get();

	assertEquals(original, reverted);
	}

	public void testRepeatableAccess() {
	assertTrue(REPLACEMENTS.length <= MAX_UNDO_LEVEL);

	final IDocument document= createDocument(INITIAL_DOCUMENT_CONTENT);
	fTextViewer.setDocument(document);

	doRepeatableChange(document);

	assertTrue(fUndoManager.undoable());
	while (fUndoManager.undoable())
	fUndoManager.undo();

	final String reverted= document.get();

	assertEquals(INITIAL_DOCUMENT_CONTENT, reverted);
	}

	public void testRepeatableAccessAsCompound() {
	assertTrue(REPLACEMENTS.length <= MAX_UNDO_LEVEL);

	final IDocument document= createDocument(INITIAL_DOCUMENT_CONTENT);
	fTextViewer.setDocument(document);

	fUndoManager.beginCompoundChange();
	doRepeatableChange(document);
	fUndoManager.endCompoundChange();

	assertTrue(fUndoManager.undoable());
	fUndoManager.undo();
	// with a single compound, there should be only one undo
	assertFalse(fUndoManager.undoable());

	final String reverted= document.get();

	assertEquals(INITIAL_DOCUMENT_CONTENT, reverted);
	}

	public void testRepeatableAccessAsUnclosedCompound() {
	assertTrue(REPLACEMENTS.length <= MAX_UNDO_LEVEL);

	final IDocument document= createDocument(INITIAL_DOCUMENT_CONTENT);
	fTextViewer.setDocument(document);

	fUndoManager.beginCompoundChange();
	doRepeatableChange(document);

	assertTrue(fUndoManager.undoable());
	while (fUndoManager.undoable())
	fUndoManager.undo();

	final String reverted= document.get();

	assertEquals(INITIAL_DOCUMENT_CONTENT, reverted);
	}

	public void testRepeatableAccessWithMixedAndEmptyCompound() {
	assertTrue(REPLACEMENTS.length + 2 <= MAX_UNDO_LEVEL);

	final IDocument document= createDocument(INITIAL_DOCUMENT_CONTENT);
	fTextViewer.setDocument(document);

	fUndoManager.beginCompoundChange();
	doRepeatableChange(document);
	fUndoManager.endCompoundChange();
	assertTrue(fUndoManager.undoable());

	// insert an empty compound
	fUndoManager.beginCompoundChange();
	fUndoManager.endCompoundChange();

	// insert the atomic changes
	doRepeatableChange(document);

	assertTrue(fUndoManager.undoable());
	while (fUndoManager.undoable())
	fUndoManager.undo();
	assertTrue(!fUndoManager.undoable());

	final String reverted= document.get();

	assertEquals(INITIAL_DOCUMENT_CONTENT, reverted);
	}

	public void testDocumentStamp() {
	final IDocument document= createDocument(INITIAL_DOCUMENT_CONTENT);
	fTextViewer.setDocument(document);
	long stamp= ((IDocumentExtension4)document).getModificationStamp();
	doChange(document, 1);
	fUndoManager.undo();
	assertEquals(stamp, ((IDocumentExtension4)document).getModificationStamp());

	}

	// see: https://bugs.eclipse.org/bugs/show_bug.cgi?id=109104
	public void testDocumentStamp2() throws BadLocationException {
	final IDocument document= createDocument("");
	final int stringLength= 13;
	fTextViewer.setDocument(document);
	document.replace(0, 0, createRandomString(stringLength));
	long stamp= ((IDocumentExtension4)document).getModificationStamp();
	fUndoManager.undo();
	document.replace(0, 0, createRandomString(stringLength));
	assertFalse(stamp == ((IDocumentExtension4)document).getModificationStamp());

	}

	private static String createRandomString(int length) {
	final StringBuffer buffer= new StringBuffer();

	for (int i= 0; i < length; i++)
	buffer.append(getRandomCharacter());

	return buffer.toString();
	}

	private static final char getRandomCharacter() {
	// XXX should include \t
	return (char) (32 + 95 * Math.random());
	}

	private static String createRandomStringPoisson() {
	final int length= getRandomPoissonValue(2);
	return createRandomString(length);
	}

	private IDocument createDocument(String contents) {
	IModelHandler handler = ModelHandlerRegistry.getInstance().getHandlerForContentTypeId("org.eclipse.core.runtime.xml");
	BasicStructuredDocument document = (BasicStructuredDocument) handler.getDocumentLoader().createNewStructuredDocument();
	document.set(contents);
	// return new Document(contents);
	return document;
	}

	private static Position createRandomPositionPoisson(int documentLength) {

	float random= (float) Math.random();
	int offset= (int) (random * (documentLength + 1));

	// Catch potential rounding issue
	if (offset == documentLength + 1)
	offset= documentLength;

	int length= getRandomPoissonValue(2);
	if (offset + length > documentLength)
	length= documentLength - offset;

	return new Position(offset, length);
	}

	private static int getRandomPoissonValue(int mean) {
	final int MAX_VALUE= 10;

	final float random= (float) Math.random();
	float probability= 0;
	int i= 0;
	while (probability < 1 && i < MAX_VALUE) {
	probability += getPoissonDistribution(mean, i);
	if (random <= probability)
	break;
	i++;
	}
	return i;
	}

	private static float getPoissonDistribution(float lambda, int k) {
	return (float) (Math.exp(-lambda) * Math.pow(lambda, k) / faculty(k));
	}

	/**
	* Returns the faculty of k.
	*
	* @param k the <code>int</code> for which to get the faculty
	* @return the faculty
	*/
	private static final int faculty(int k) {
	return k == 0
	? 1
	: k * faculty(k - 1);
	}

	}