/*******************************************************************************
* 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);
}
}