merge pre_3_3_work changes:

- added more text store tests
- replaced usage of deprecated GapTextStore ctor
- incremented minor version

10 files changed, 729 insertions, 98 deletions

diff --git a/org.eclipse.text.tests/plugin.xml b/org.eclipse.text.tests/plugin.xml
index 89fdac41a58..337c1d023b3 100644
--- a/org.eclipse.text.tests/plugin.xml
+++ b/org.eclipse.text.tests/plugin.xml
@@ -2,7 +2,7 @@
 <plugin
    id="org.eclipse.text.tests"
    name="%Plugin.name"
-   version="3.2.0.qualifier"
+   version="3.3.0.qualifier"
    provider-name="%Plugin.providerName"
    class="">
 
diff --git a/org.eclipse.text.tests/src/org/eclipse/text/tests/AbstractGapTextTest.java b/org.eclipse.text.tests/src/org/eclipse/text/tests/AbstractGapTextTest.java
new file mode 100644
index 00000000000..dec1f4eecc6
--- /dev/null
+++ b/org.eclipse.text.tests/src/org/eclipse/text/tests/AbstractGapTextTest.java
@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * Copyright (c) 2006 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.text.tests;
+
+import junit.framework.TestCase;
+
+import org.eclipse.jface.text.GapTextStore;
+
+/**
+ * A test specifically testing the gap property of a gap text store.
+ * 
+ * @since 3.3
+ */
+public class AbstractGapTextTest extends TestCase {
+	protected static class GapText extends GapTextStore {
+		/**
+		 * @deprecated
+		 */
+		public GapText(int lowWaterMark, int highWaterMark) {
+			super(lowWaterMark, highWaterMark);
+		}
+		
+		public GapText(int min, int max, float maxGapFactor) {
+			super(min, max, maxGapFactor);
+		}
+
+		String getText() {
+			return super.getContentAsString();
+		}
+
+		int getGapStart() {
+			return super.getGapStartIndex();
+		}
+
+		int getGapEnd() {
+			return super.getGapEndIndex();
+		}
+
+		int getRawLength() {
+			return super.getContentAsString().length();
+		}
+	}
+		
+	protected GapText fText;
+	
+	private String printGap() {
+		return printGap(fText.getGapStart(), fText.getGapEnd());
+	}
+	
+	private String printGap(int start, int end) {
+		return "[" + start + "," + end + "]";
+	}
+	
+	protected void assertGap(int start, int end) {
+		assertTrue("Invalid gap. Expected: " + printGap(start, end) + " actual:" + printGap() , fText.getGapStart() == start && fText.getGapEnd() == end);
+	}
+	
+	protected void assertContents(String expected) {
+		assertEquals(expected, fText.get(0, fText.getLength()));
+	}
+}
diff --git a/org.eclipse.text.tests/src/org/eclipse/text/tests/AdaptiveGapTextTest.java b/org.eclipse.text.tests/src/org/eclipse/text/tests/AdaptiveGapTextTest.java
new file mode 100644
index 00000000000..b22f482e89d
--- /dev/null
+++ b/org.eclipse.text.tests/src/org/eclipse/text/tests/AdaptiveGapTextTest.java
@@ -0,0 +1,155 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2005 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.text.tests;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+
+public class AdaptiveGapTextTest extends AbstractGapTextTest {
+	protected void setUp() {
+		fText= new GapText(2, 10, 0.5f);
+		fText.set("xxxxx");
+	}
+	
+	public static Test suite() {
+		return new TestSuite(AdaptiveGapTextTest.class); 
+	}
+	
+	protected void tearDown () {
+		fText= null;
+	}
+	
+	public void testSet() {
+		assertGap(5, 7);
+	}
+		
+	public void testGetText1() {
+		String[] expected= {
+			"xyxxxx",
+			"xyxyxxx",
+			"xyxyxyxx",
+			"xyxyxyxyx",
+			"xyxyxyxyxy"
+		};
+		
+		for (int i= 1; i < 5; i++) {
+			fText.replace(2 * i - 1, 0, "y");
+			assertContents(expected[i - 1]);
+		}
+	
+	}
+	
+	public void testGetText2() {
+		String[] expected= {
+			"yxxxxx",
+			"yxyxxxx",
+			"yxyxyxxx",
+			"yxyxyxyxx",
+			"yxyxyxyxyx"
+		};
+		
+		for (int i= 1; i < 5; i++) {
+			fText.replace(2 * (i - 1), 0, "y");
+			assertContents(expected[i - 1]);
+		}
+	
+	}
+	
+	public void testInsert() {
+		fText.replace(2, 0, "y");
+		assertGap(3, 4);
+	
+		
+		for (int i= 1; i <= 1; i++) {
+			fText.replace(2 + i, 0, "y");
+			assertGap(3 + i, 4);
+		}
+	
+		fText.replace(7, 0, "y");
+		assertGap(8, 10);
+	}
+
+	public void testRemoveGapOverlapping() {
+		fText.replace(2, 2, null);
+		assertGap(2, 6);
+	
+		fText.replace(1, 2, null);
+		assertGap(1, 3);
+	}
+	
+	public void testRemoveGapOverlapping2() {
+		fText.replace(0, 0, "aaaaazzzzzyyyyy");
+		assertGap(15, 21);
+		assertContents("aaaaazzzzzyyyyyxxxxx");
+	
+	
+		fText.replace(5, 12, null);
+		assertGap(5, 7);
+		assertContents("aaaaaxxx");
+	}
+	
+	public void testRemoveRemoteFromGap() {
+		fText.replace(0, 0, "aaaaazzzzzyyyyy");
+		assertGap(15, 21);
+		assertContents("aaaaazzzzzyyyyyxxxxx");
+	
+		// before gap
+		fText.replace(5, 2, null);
+		assertGap(5, 13);
+		assertContents("aaaaazzzyyyyyxxxxx");
+		
+		// after gap
+		fText.replace(7, 10, null);
+		assertGap(7, 9);
+		assertContents("aaaaazzx");
+	
+	}
+	
+	public void testRemoveAtLeftGapEdge() {
+		fText.replace(4, 0, "xxx");
+		assertGap(7, 9);
+		fText.replace(6, 0, "x");
+		assertGap(7, 8);
+		fText.replace(6, 1, null);
+		assertGap(6, 8);
+	}
+	
+	public void testRemoveAtRightGapEdge() {
+		fText.replace(4, 0, "xxx");
+		assertGap(7, 9);
+		fText.replace(6, 0, "x");
+		assertGap(7, 8);
+		fText.replace(7, 1, null);
+		assertGap(7, 9);
+	}
+	
+	public void testReplace() {
+		fText.replace(2, 2, "yy");
+		assertGap(4, 6);
+	
+		fText.replace(2, 1, "yyyyyyyyyyyy");
+		assertGap(14, 19);
+	
+		fText.replace(14, 0, "yyy");
+		assertGap(17, 19);
+	}
+	
+	public void testRemoveReallocateBeforeGap() throws Exception {
+	    fText.replace(0, 0, "yyyyyzzzzz");
+	    assertGap(10, 15);
+	    assertContents("yyyyyzzzzzxxxxx");
+	    
+	    fText.replace(2, 6, null);
+	    assertGap(2, 5);
+	    assertContents("yyzzxxxxx");
+    }
+}
diff --git a/org.eclipse.text.tests/src/org/eclipse/text/tests/CopyOnWriteTextStoreTest.java b/org.eclipse.text.tests/src/org/eclipse/text/tests/CopyOnWriteTextStoreTest.java
index 21e178ce494..93a39e88340 100644
--- a/org.eclipse.text.tests/src/org/eclipse/text/tests/CopyOnWriteTextStoreTest.java
+++ b/org.eclipse.text.tests/src/org/eclipse/text/tests/CopyOnWriteTextStoreTest.java
@@ -28,7 +28,7 @@ public class CopyOnWriteTextStoreTest extends TestCase {
 
 	private static class COWTextStore extends CopyOnWriteTextStore {
 		COWTextStore() {
-			super(new GapTextStore(50, 300));
+			super(new GapTextStore());
 		}
 		ITextStore getStore() {
 			return fTextStore;
diff --git a/org.eclipse.text.tests/src/org/eclipse/text/tests/EclipseTextTestSuite.java b/org.eclipse.text.tests/src/org/eclipse/text/tests/EclipseTextTestSuite.java
index 22827640c69..634e2fda359 100644
--- a/org.eclipse.text.tests/src/org/eclipse/text/tests/EclipseTextTestSuite.java
+++ b/org.eclipse.text.tests/src/org/eclipse/text/tests/EclipseTextTestSuite.java
@@ -35,6 +35,8 @@ public class EclipseTextTestSuite {
 		suite.addTest(PositionUpdatingCornerCasesTest.suite());
 		suite.addTest(TextEditTests.suite());
 		suite.addTest(GapTextTest.suite());
+		suite.addTest(AdaptiveGapTextTest.suite());
+		suite.addTest(GapTextStoreTest.suite());
 		suite.addTest(ChildDocumentTest.suite());
 		suite.addTest(ProjectionTestSuite.suite());
 		suite.addTest(LinkTestSuite.suite());
diff --git a/org.eclipse.text.tests/src/org/eclipse/text/tests/GapTextStoreTest.java b/org.eclipse.text.tests/src/org/eclipse/text/tests/GapTextStoreTest.java
new file mode 100644
index 00000000000..305fa5a9efd
--- /dev/null
+++ b/org.eclipse.text.tests/src/org/eclipse/text/tests/GapTextStoreTest.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.text.tests;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+import org.eclipse.jface.text.GapTextStore;
+import org.eclipse.jface.text.ITextStore;
+
+public class GapTextStoreTest extends TextStoreTest {
+
+	public static Test suite() {
+		return new TestSuite(GapTextStoreTest.class); 
+	}
+	
+	protected ITextStore createTextStore() {
+		return new GapTextStore(256, 4096, 0.1f);
+	}
+
+}
diff --git a/org.eclipse.text.tests/src/org/eclipse/text/tests/GapTextTest.java b/org.eclipse.text.tests/src/org/eclipse/text/tests/GapTextTest.java
index c7c71b54d6c..2e36b7e9fbf 100644
--- a/org.eclipse.text.tests/src/org/eclipse/text/tests/GapTextTest.java
+++ b/org.eclipse.text.tests/src/org/eclipse/text/tests/GapTextTest.java
@@ -11,51 +11,14 @@
 package org.eclipse.text.tests;
 
 import junit.framework.Test;
-import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
-import org.eclipse.jface.text.GapTextStore;
-
-
-public class GapTextTest extends TestCase {
-
-	static class GapText extends GapTextStore {
-		
-		public GapText() {
-			super(5, 10);
-		}
-
-		String getText() {
-			return super.getContentAsString();
-		}
-
-		int getGapStart() {
-			return super.getGapStartIndex();
-		}
-
-		int getGapEnd() {
-			return super.getGapEndIndex();
-		}
-
-		int getRawLength() {
-			return super.getContentAsString().length();
-		}
-	}
-		
-	private GapText fText;
-	
-	
-	public GapTextTest(String name) {
-		super(name);
-	}
-	
-	protected String printGap() {
-		return "[" + fText.getGapStart() + "," + fText.getGapEnd() + "]";
-	}
-	
+public class GapTextTest extends AbstractGapTextTest {
+	/**
+	 * @deprecated tests the legacy constructor of GapTextStore
+	 */
 	protected void setUp() {
-	
-		fText= new GapText();
+		fText= new GapText(5, 10);
 		fText.set("xxxxx");
 	}
 	
@@ -66,11 +29,12 @@ public class GapTextTest extends TestCase {
 	protected void tearDown () {
 		fText= null;
 	}
+	
+	public void testSet() {
+		assertGap(5, 10);
+	}
 		
 	public void testGetText1() {
-	
-		assertTrue("invalid gap", fText.getGapStart() == -1 && fText.getGapEnd() == -1);
-	
 		String[] expected= {
 			"xyxxxx",
 			"xyxyxxx",
@@ -81,16 +45,12 @@ public class GapTextTest extends TestCase {
 		
 		for (int i= 1; i < 5; i++) {
 			fText.replace(2 * i - 1, 0, "y");
-			String txt= fText.get(0, fText.getLength());
-			assertEquals("invalid text \'" + txt + "\' returned, should be \'" + expected[i - 1] + "\'", expected[i - 1],  txt);
+			assertContents(expected[i - 1]);
 		}
 	
 	}
 	
 	public void testGetText2() {
-	
-		assertTrue("invalid gap", fText.getGapStart() == -1 && fText.getGapEnd() == -1);
-	
 		String[] expected= {
 			"yxxxxx",
 			"yxyxxxx",
@@ -101,96 +61,97 @@ public class GapTextTest extends TestCase {
 		
 		for (int i= 1; i < 5; i++) {
 			fText.replace(2 * (i - 1), 0, "y");
-			String txt= fText.get(0, fText.getLength());
-			assertEquals("invalid text \'" + txt + "\' returned, should be \'" + expected[i - 1] + "\'", expected[i - 1], txt);
+			assertContents(expected[i - 1]);
 		}
 	
 	}
 	
 	public void testInsert() {
-	
-		assertTrue("invalid gap", fText.getGapStart() == -1 && fText.getGapEnd() == -1);
 		fText.replace(2, 0, "y");
-		assertTrue("invalid gap:" + printGap(), fText.getGapStart() == 3 && fText.getGapEnd() == 13);
+		assertGap(3, 7);
 	
 		
-		for (int i= 1; i <= 5; i++) {
+		for (int i= 1; i <= 4; i++) {
 			fText.replace(2 + i, 0, "y");
-			assertTrue("invalid gap:" + printGap(), fText.getGapStart() == (3 + i) && fText.getGapEnd() == 13);
+			assertGap(3 + i, 7);
 		}
 	
-		fText.replace(8, 0, "y");
-		assertTrue("invalid gap:" + printGap(), fText.getGapStart() == 9 && fText.getGapEnd() == 19);
+		fText.replace(7, 0, "y");
+		assertGap(8, 13);
 	}
-	
+
 	public void testRemoveGapOverlapping() {
-	
-		assertTrue("invalid gap", fText.getGapStart() == -1 && fText.getGapEnd() == -1);
 		fText.replace(2, 2, null);
-		assertTrue("invalid gap: " + printGap(), fText.getGapStart() == 2 && fText.getGapEnd() == 12);
+		assertGap(2, 9);
 	
 		fText.replace(1, 2, null);
-		assertTrue("invalid gap: " + printGap(), fText.getGapStart() == 1 && fText.getGapEnd() == 13);
+		assertGap(1, 10);
 	}
 	
 	public void testRemoveGapOverlapping2() {
-	
-		assertTrue("invalid gap", fText.getGapStart() == -1 && fText.getGapEnd() == -1);
 		fText.replace(0, 0, "aaaaazzzzzyyyyy");
-		assertTrue("invalid gap:" + printGap(), fText.getGapStart() == 15 && fText.getGapEnd() == 25);
-		assertEquals("aaaaazzzzzyyyyyxxxxx", fText.get(0, fText.getLength()));
+		assertGap(15, 20);
+		assertContents("aaaaazzzzzyyyyyxxxxx");
 	
 	
 		fText.replace(5, 12, null);
-		assertTrue("invalid gap:" + printGap(), fText.getGapStart() == 5 && fText.getGapEnd() == 27);
-		assertEquals("aaaaaxxx", fText.get(0, fText.getLength()));
+		assertGap(5, 10);
+		assertContents("aaaaaxxx");
 	}
 	
 	public void testRemoveRemoteFromGap() {
-	
-		assertTrue("invalid gap", fText.getGapStart() == -1 && fText.getGapEnd() == -1);
 		fText.replace(0, 0, "aaaaazzzzzyyyyy");
-		assertTrue("invalid gap:" + printGap(), fText.getGapStart() == 15 && fText.getGapEnd() == 25);
-		assertEquals("aaaaazzzzzyyyyyxxxxx", fText.get(0, fText.getLength()));
+		assertGap(15, 20);
+		assertContents("aaaaazzzzzyyyyyxxxxx");
 	
 		// before gap
 		fText.replace(5, 2, null);
-		assertTrue("invalid gap:" + printGap(), fText.getGapStart() == 5 && fText.getGapEnd() == 15);
-		assertEquals("aaaaazzzyyyyyxxxxx", fText.get(0, fText.getLength()));
+		assertGap(5, 12);
+		assertContents("aaaaazzzyyyyyxxxxx");
 		
 		// after gap
 		fText.replace(7, 10, null);
-		assertTrue("invalid gap:" + printGap(), fText.getGapStart() == 7 && fText.getGapEnd() == 17);
-		assertEquals("aaaaazzx", fText.get(0, fText.getLength()));
+		assertGap(7, 12);
+		assertContents("aaaaazzx");
 	
 	}
 	
 	public void testRemoveAtLeftGapEdge() {
-		assertTrue("invalid gap", fText.getGapStart() == -1 && fText.getGapEnd() == -1);
-		fText.replace(2, 0, "xxxxx");
-		assertTrue("invalid gap: " + printGap(), fText.getGapStart() == 7 && fText.getGapEnd() == 17);
+		fText.replace(4, 0, "xxx");
+		assertGap(7, 9);
+		fText.replace(6, 0, "x");
+		assertGap(7, 8);
 		fText.replace(6, 1, null);
-		assertTrue("invalid gap: " + printGap(), fText.getGapStart() == 6 && fText.getGapEnd() == 17);
+		assertGap(6, 8);
 	}
 	
 	public void testRemoveAtRightGapEdge() {
-		assertTrue("invalid gap", fText.getGapStart() == -1 && fText.getGapEnd() == -1);
-		fText.replace(2, 0, "xxxxx");
-		assertTrue("invalid gap: " + printGap(), fText.getGapStart() == 7 && fText.getGapEnd() == 17);
+		fText.replace(4, 0, "xxx");
+		assertGap(7, 9);
+		fText.replace(6, 0, "x");
+		assertGap(7, 8);
 		fText.replace(7, 1, null);
-		assertTrue("invalid gap: " + printGap(), fText.getGapStart() == 7 && fText.getGapEnd() == 18);
+		assertGap(7, 9);
 	}
 	
 	public void testReplace() {
-	
-		assertTrue("invalid gap", fText.getGapStart() == -1 && fText.getGapEnd() == -1);
 		fText.replace(2, 2, "yy");
-		assertTrue("invalid gap:" + printGap(), fText.getGapStart() == 4 && fText.getGapEnd() == 14);
-	
-		fText.replace(4, 1, "yyyyyyyyyy");
-		assertTrue("invalid gap:" + printGap(), fText.getGapStart() == 14 && fText.getGapEnd() == 24);
+		assertGap(4, 9);
+		
+		fText.replace(2, 1, "yyyyyyyyyyyy");
+		assertGap(14, 19);
 	
 		fText.replace(14, 0, "yyy");
-		assertTrue("invalid gap:" + printGap(), fText.getGapStart() == 17 && fText.getGapEnd() == 24);
+		assertGap(17, 19);
 	}
+	
+	public void testRemoveReallocateBeforeGap() throws Exception {
+	    fText.replace(0, 0, "yyyyyzzzzz");
+	    assertGap(10, 15);
+	    assertContents("yyyyyzzzzzxxxxx");
+	    
+	    fText.replace(2, 6, null);
+	    assertGap(2, 7);
+	    assertContents("yyzzxxxxx");
+    }
 }
diff --git a/org.eclipse.text.tests/src/org/eclipse/text/tests/LineTrackerTest3.java b/org.eclipse.text.tests/src/org/eclipse/text/tests/LineTrackerTest3.java
index 561f675e952..109fd0770c8 100644
--- a/org.eclipse.text.tests/src/org/eclipse/text/tests/LineTrackerTest3.java
+++ b/org.eclipse.text.tests/src/org/eclipse/text/tests/LineTrackerTest3.java
@@ -29,7 +29,7 @@ public class LineTrackerTest3 extends AbstractLineTrackerTest {
 	}
 
 	protected void setUp() {
-		fText= new GapTextStore(50, 300);
+		fText= new GapTextStore();
 		fTracker= new ConfigurableLineTracker(new String[] { "\n" });
 		set("x\nx\nx\nx\nx\n");
 	}
@@ -233,7 +233,7 @@ public class LineTrackerTest3 extends AbstractLineTrackerTest {
 	}
 
 	public void testMultipleNewlines() throws Exception {
-		fText= new GapTextStore(50, 300);
+		fText= new GapTextStore();
 		fTracker= new ConfigurableLineTracker(new String[] { "\n" });
 		set("x\n\nx\nx\n\nx\nx\n");
 
diff --git a/org.eclipse.text.tests/src/org/eclipse/text/tests/LineTrackerTest4.java b/org.eclipse.text.tests/src/org/eclipse/text/tests/LineTrackerTest4.java
index 2aa93510d8b..c7a0a0e499e 100644
--- a/org.eclipse.text.tests/src/org/eclipse/text/tests/LineTrackerTest4.java
+++ b/org.eclipse.text.tests/src/org/eclipse/text/tests/LineTrackerTest4.java
@@ -28,7 +28,7 @@ public class LineTrackerTest4 extends AbstractLineTrackerTest {
 	}
 
 	protected void setUp() {
-		fText= new GapTextStore(50, 300);
+		fText= new GapTextStore();
 		fTracker= new ConfigurableLineTracker(new String[] { "\r\n" });
 		set("x\r\nx\r\nx\r\nx\r\nx\r\n");
 	}
diff --git a/org.eclipse.text.tests/src/org/eclipse/text/tests/TextStoreTest.java b/org.eclipse.text.tests/src/org/eclipse/text/tests/TextStoreTest.java
new file mode 100644
index 00000000000..39b5c570535
--- /dev/null
+++ b/org.eclipse.text.tests/src/org/eclipse/text/tests/TextStoreTest.java
@@ -0,0 +1,415 @@
+/*******************************************************************************
+ * Copyright (c) 2006 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.text.tests;
+
+import junit.framework.TestCase;
+
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.ConfigurableLineTracker;
+import org.eclipse.jface.text.ILineTracker;
+import org.eclipse.jface.text.IRegion;
+import org.eclipse.jface.text.ITextStore;
+
+/**
+ * Correctness tests for {@link ITextStore} implementations.
+ * 
+ * @since 3.3
+ */
+public abstract class TextStoreTest extends TestCase {
+
+	private ITextStore fTextStore;
+	private ILineTracker fTracker;
+
+	protected void setUp() {
+
+		fTextStore= createTextStore();
+		fTracker= createTracker();
+		set("x\nx\nx\nx\nx\n");
+	}
+
+	protected ILineTracker createTracker() {
+		return new ConfigurableLineTracker(new String[]{"\n"});
+	}
+	
+	protected final void replace(int offset, int length, String text) throws BadLocationException {
+		fTextStore.replace(offset, length, text);
+		fTracker.replace(offset, length, text);
+	}
+	
+	protected final void set(String text) {
+		fTextStore.set(text);
+		fTracker.set(text);
+	}
+
+	abstract protected ITextStore createTextStore();
+
+	protected void tearDown() {
+		fTextStore= null;
+		fTracker= null;
+	}
+
+	public void testGet1() throws Exception {
+		set("xxxxx");
+
+		String[] expected= {"xyxxxx", "xyxyxxx", "xyxyxyxx", "xyxyxyxyx", "xyxyxyxyxy"};
+
+		for (int i= 1; i < 5; i++) {
+			replace(2 * i - 1, 0, "y");
+			String txt= fTextStore.get(0, fTextStore.getLength());
+			assertEquals(expected[i - 1], txt);
+		}
+
+	}
+
+	public void testGet2() throws Exception {
+		set("xxxxx");
+
+		String[] expected= {"yxxxxx", "yxyxxxx", "yxyxyxxx", "yxyxyxyxx", "yxyxyxyxyx"};
+
+		for (int i= 1; i < 5; i++) {
+			replace(2 * (i - 1), 0, "y");
+			String txt= fTextStore.get(0, fTextStore.getLength());
+			assertEquals(expected[i - 1], txt);
+		}
+
+	}
+	public void testEditScript1() throws Exception {
+		replace(0, fTextStore.getLength(), "x");
+		assertTextStoreContents("x");
+
+		replace(1, 0, "y");
+		assertTextStoreContents("xy");
+
+		replace(2, 0, "z");
+		assertTextStoreContents("xyz");
+
+		replace(3, 0, "\n");
+		assertTextStoreContents("xyz\n");
+
+		replace(4, 0, "x");
+		assertTextStoreContents("xyz\nx");
+	}
+
+	private void assertTextStoreContents(String expected) {
+		assertEquals(expected, fTextStore.get(0, fTextStore.getLength()));
+		for (int i= 0; i < fTextStore.getLength(); i++)
+			assertEquals(expected.charAt(i), fTextStore.get(i));
+
+		try {
+			fTextStore.get(fTextStore.getLength());
+			fail();
+		} catch (IndexOutOfBoundsException e) {
+		}
+	}
+
+	public void testEmptyLines() throws Exception {
+
+		replace(0, 10, null);
+		assertTextStoreContents("");
+
+		replace(0, 0, "\n\n\n\n\n");
+		assertTextStoreContents("\n\n\n\n\n");
+	}
+
+	public void testInsert1() throws Exception {
+
+		replace(3, 0, "yyyy");
+		assertTextStoreContents("x\nxyyyy\nx\nx\nx\n");
+
+		replace(9, 0, "y\n");
+		assertTextStoreContents("x\nxyyyy\nxy\n\nx\nx\n");
+
+		replace(11, 0, "y\n");
+		assertTextStoreContents("x\nxyyyy\nxy\ny\n\nx\nx\n");
+
+		replace(13, 0, "y");
+		assertTextStoreContents("x\nxyyyy\nxy\ny\ny\nx\nx\n");
+		
+		replace(11, 5, "y\nxyz");
+		assertTextStoreContents("x\nxyyyy\nxy\ny\nxyz\nx\n");
+	}
+
+	public void testInsert2() throws Exception {
+		replace(3, 0, "yyyy");
+		assertTextStoreContents("x\nxyyyy\nx\nx\nx\n");
+
+		replace(9, 0, "y\ny\ny");
+		assertTextStoreContents("x\nxyyyy\nxy\ny\ny\nx\nx\n");
+	}
+
+	public void testLinesNumbers() throws Exception {
+		replace(0, 10, "\na\nbb\nccc\ndddd\neeeee\n");
+		assertTextStoreContents("\na\nbb\nccc\ndddd\neeeee\n");
+
+		int offset= 0;
+		for (int i= 0; i < 5; i++) {
+			for (int j= 0; j < i; j++) {
+				int no= fTracker.getLineNumberOfOffset(offset + j);
+				assertTrue("invalid line number " + no + " reported instead of " + i, no == i);
+			}
+			offset+= (i + 1);
+		}
+	}
+
+	public void testOffsets() throws Exception {
+		for (int i= 0; i < 5; i++) {
+			IRegion line= fTracker.getLineInformation(i);
+			int pos= line.getOffset() + line.getLength();
+			int offset= (2 * i) + 1;
+			assertTrue("invalid line end offset " + pos + " for line " + i + " should be " + offset, offset == pos);
+		}
+
+		for (int i= 0; i < 5; i++) {
+			int pos= fTracker.getLineOffset(i);
+			int offset= 2 * i;
+			assertTrue("invalid line start offset " + pos + " for line " + i + " should be " + offset, pos == offset);
+		}
+
+		for (int i= 0; i < 10; i++) {
+			int line= fTracker.getLineNumberOfOffset(i);
+			double l= Math.floor(i / 2);
+			assertTrue("invalid line number " + line + " for position " + i + " should be " + l, l == line);
+		}
+	}
+
+	public void testRemove() throws Exception {
+		replace(3, 1, null);
+		assertTextStoreContents("x\nxx\nx\nx\n");
+
+		replace(6, 1, null);
+		assertTextStoreContents("x\nxx\nxx\n");
+
+		replace(3, 5, null);
+		assertTextStoreContents("x\nx");
+
+		replace(0, 3, null);
+		assertTextStoreContents("");
+	}
+
+	public void testReplace() throws Exception {
+		replace(0, fTextStore.getLength(), "\tx\n\tx\n\tx\n\tx\n\tx\n");
+		assertTextStoreContents("\tx\n\tx\n\tx\n\tx\n\tx\n");
+	}
+
+	public void testReplace2() throws Exception {
+		replace(0, fTextStore.getLength(), "x");
+		assertTextStoreContents("x");
+
+		replace(0, fTextStore.getLength(), "x\nx\nx\n");
+		assertTextStoreContents("x\nx\nx\n");
+	}
+
+	public void testReplace3() throws Exception {
+		replace(1, 1, "\n");
+		assertTextStoreContents("x\nx\nx\nx\nx\n");
+	}
+
+	public void testReplace4() throws Exception {
+		int lines= fTracker.getNumberOfLines();
+		IRegion previous= fTracker.getLineInformation(0);
+		for (int i= 1; i < lines; i++) {
+			int lastLineEnd= previous.getOffset() + previous.getLength();
+			int lineStart= fTracker.getLineInformation(i).getOffset();
+			replace(lastLineEnd, lineStart - lastLineEnd, "\n");
+			assertTextStoreContents("x\nx\nx\nx\nx\n");
+			previous= fTracker.getLineInformation(i);
+		}
+	}
+
+	public void testShiftLeft() throws Exception {
+		replace(0, fTextStore.getLength(), "\tx\n\tx\n\tx\n\tx\n\tx\n");
+		assertTextStoreContents("\tx\n\tx\n\tx\n\tx\n\tx\n");
+
+		for (int i= 0; i < 5; i++) {
+			int pos= fTracker.getLineOffset(i);
+			replace(pos, 1, null);
+		}
+
+		assertTextStoreContents("x\nx\nx\nx\nx\n");
+	}
+
+	public void testShiftRight() throws Exception {
+		for (int i= 0; i < 5; i++) {
+			int pos= fTracker.getLineOffset(i);
+			replace(pos, 0, "\t");
+		}
+
+		assertTextStoreContents("\tx\n\tx\n\tx\n\tx\n\tx\n");
+	}
+
+	public void testDeleteEmptyLine() throws Exception {
+		set("x\nx\n\nx\n\n");
+		assertTextStoreContents("x\nx\n\nx\n\n");
+		
+		String[] expected= {
+				"",
+				"x\n",
+				"x\nx\n",
+				"x\nx\n\n",
+				"x\nx\n\nx\n",
+				"x\nx\n\nx\n\n",
+		};
+
+		for (int line= fTracker.getNumberOfLines() - 1; line >= 0; line--) {
+			int offset= fTracker.getLineOffset(line);
+			int length= fTracker.getLineLength(line);
+			replace(offset, length, null);
+			assertTextStoreContents(expected[line]);
+		}
+
+	}
+
+	public void testDeleteLines() throws Exception {
+		String content= "";
+		for (int i= 0; i < 50; i++) {
+			content += "x\nx\n\nx\n\n";
+			set(content);
+
+			String expected= content;
+			int lines= fTracker.getNumberOfLines();
+			for (int line= 0; line < lines; line++) {
+				int offset= fTracker.getLineOffset(0);
+				int length= fTracker.getLineLength(0);
+				replace(offset, length, null);
+				expected= expected.substring(length);
+				assertTextStoreContents(expected);
+			}
+		}
+		content= "";
+		for (int i= 0; i < 50; i++) {
+			content += "x\nx\n\nx\n\n";
+			set(content);
+			
+			String expected= content;
+			int lines= fTracker.getNumberOfLines();
+			for (int line= lines - 1; line >= 0; line--) {
+				int offset= fTracker.getLineOffset(line);
+				int length= fTracker.getLineLength(line);
+				replace(offset, length, null);
+				expected= expected.substring(0, expected.length() - length);
+				assertTextStoreContents(expected);
+			}
+		}
+	}
+
+	public void testDeleteLines2() throws Exception {
+		String content= "";
+		for (int i= 0; i < 50; i++) {
+			content += "xxxxxxxxxxxxxx";
+			set(content);
+			
+			String expected= content;
+			int lines= fTracker.getNumberOfLines();
+			for (int line= 0; line < lines; line++) {
+				int offset= fTracker.getLineOffset(0);
+				int length= fTracker.getLineLength(0);
+				replace(offset, length, null);
+				expected= expected.substring(length);
+				assertTextStoreContents(expected);
+			}
+		}
+		content= "";
+		for (int i= 0; i < 50; i++) {
+			content += "xxxxxxxxxxxxxx";
+			set(content);
+			
+			String expected= content;
+			int lines= fTracker.getNumberOfLines();
+			for (int line= lines - 1; line >= 0; line--) {
+				int offset= fTracker.getLineOffset(line);
+				int length= fTracker.getLineLength(line);
+				replace(offset, length, null);
+				expected= expected.substring(0, expected.length() - length);
+				assertTextStoreContents(expected);
+			}
+		}
+	}
+	
+	public void testSet() throws Exception {
+		String content= "";
+		for (int i= 0; i < 35; i++) {
+			int[] lenghts= new int[i + 1];
+			for (int j= 0; j < i + 1; j++)
+				lenghts[j]= j;
+			for (int j= 0; j < i; j++)
+				content+= "x";
+
+			set(content);
+			assertTextStoreContents(content);
+
+			content+= "\n";
+		}
+	}
+
+	public void testFunnyLastLineCompatibility() throws Exception {
+		/* empty last line */
+		set("x\n");
+		assertTextStoreContents("x\n");
+		int[] offsets= {0, 2};
+		int[] lengths= {1, 0};
+
+		assertEquals("invalid number of lines, ", lengths.length, fTracker.getNumberOfLines());
+		assertEquals("invalid number of lines, ", lengths.length, fTracker.getNumberOfLines(0, fTextStore.getLength()));
+		for (int i= 0; i < lengths.length; i++) {
+			IRegion line= fTracker.getLineInformation(i);
+			assertEquals("line: " + i, lengths[i], line.getLength());
+			assertEquals("line: " + i, offsets[i], line.getOffset());
+		}
+		try {
+			fTracker.getLineInformation(lengths.length);
+			fail();
+		} catch (Exception e) {
+		}
+
+		try {
+			fTracker.getLineInformationOfOffset(offsets[offsets.length] + 1);
+			fail();
+		} catch (Exception e) {
+		}
+
+		/* phantom last line when the last line is not empty */
+		set("x\nx");
+		assertTextStoreContents("x\nx");
+		offsets= new int[]{0, 2, 3};
+		lengths= new int[]{1, 1, 0};
+		assertEquals("invalid number of lines, ", lengths.length - 1 /* !!!! */, fTracker.getNumberOfLines());
+		assertEquals("invalid number of lines, ", lengths.length - 1 /* !!!! */, fTracker.getNumberOfLines(0, fTextStore.getLength()));
+		for (int i= 0; i < lengths.length; i++) {
+			IRegion line= fTracker.getLineInformation(i);
+			int len= lengths[i];
+			int offset= offsets[i];
+			assertEquals("length of line: " + i, len, line.getLength());
+			assertEquals("offset of line: " + i, offset, line.getOffset());
+
+			line= fTracker.getLineInformationOfOffset(offset);
+			if (i == lengths.length - 1) { // phantom line cannot be queried by offset
+				len= lengths[i - 1];
+				offset= offsets[i - 1];
+			}
+			assertEquals("length of line: " + i, len, line.getLength());
+			assertEquals("offset of line: " + i, offset, line.getOffset());
+		}
+
+		try {
+			fTracker.getLineInformation(lengths.length);
+			fail();
+		} catch (Exception e) {
+		}
+
+		try {
+			fTracker.getLineInformationOfOffset(offsets[offsets.length] + 1);
+			fail();
+		} catch (Exception e) {
+		}
+
+	}
+
+}