Removed trailing whitespace and organized the importsv20080909-ascu

11 files changed, 390 insertions, 391 deletions

diff --git a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/quickdiff/tests/LevenshteinTest.java b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/quickdiff/tests/LevenshteinTest.java
index 59d6810166b..c6db2b740da 100644
--- a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/quickdiff/tests/LevenshteinTest.java
+++ b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/quickdiff/tests/LevenshteinTest.java
@@ -13,10 +13,9 @@ package org.eclipse.ui.workbench.texteditor.quickdiff.tests;
 
 import java.util.Arrays;
 
-import org.eclipse.core.runtime.Assert;
-
 import junit.framework.TestCase;
 
+import org.eclipse.core.runtime.Assert;
 
 import org.eclipse.ui.internal.texteditor.quickdiff.compare.rangedifferencer.IRangeComparator;
 import org.eclipse.ui.internal.texteditor.quickdiff.compare.rangedifferencer.Levenshtein;
@@ -28,8 +27,8 @@ import org.eclipse.ui.internal.texteditor.quickdiff.compare.rangedifferencer.Ran
  * @since 3.1
  */
 public class LevenshteinTest extends TestCase {
-	
-	
+
+
 	protected void setUp() throws Exception {
 		System.out.println();
 	}
@@ -46,7 +45,7 @@ public class LevenshteinTest extends TestCase {
 		assertEditDistance(2, "a", "bb");
 
 		assertEditDistance(2, "abcdefghijklmnopqrstuvwxyz", "abcdefhijklmnogpqrstuvwxyz");
-		
+
 		assertEditDistance(16, "abcdefghijklmnopqrstuvwxyz", "abcdefwxyz");
 
 		assertEditDistance(28, "abcdefghijklmnopqrstuvwxyz", "abcdefghijklm0000000000000000000000000000nopqrstuvwxyz");
@@ -56,13 +55,13 @@ public class LevenshteinTest extends TestCase {
 		assertEditDistance(0, "abcdefghijklm0000000000000000000000000000nopqrstuvwxyz", "abcdefghijklm0000000000000000000000000000nopqrstuvwxyz");
 
 		assertEditDistance(54, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
-		
+
 		assertEditDistance(51, "abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc", "abc");
 
 		assertEditDistance(25, "abcdefgxxxxxxxxxxxabcabcdefgxxxxxxx", "abcabcdefg");
 
 	}
-	
+
 	public void testEditDistanceHirschberg() {
 		assertEditDistanceHirschberg(0, "", "");
 
@@ -75,7 +74,7 @@ public class LevenshteinTest extends TestCase {
 		assertEditDistanceHirschberg(2, "a", "bb");
 
 		assertEditDistanceHirschberg(2, "abcdefghijklmnopqrstuvwxyz", "abcdefhijklmnogpqrstuvwxyz");
-		
+
 		assertEditDistanceHirschberg(16, "abcdefghijklmnopqrstuvwxyz", "abcdefwxyz");
 
 		assertEditDistanceHirschberg(28, "abcdefghijklmnopqrstuvwxyz", "abcdefghijklm0000000000000000000000000000nopqrstuvwxyz");
@@ -85,13 +84,13 @@ public class LevenshteinTest extends TestCase {
 		assertEditDistanceHirschberg(0, "abcdefghijklm0000000000000000000000000000nopqrstuvwxyz", "abcdefghijklm0000000000000000000000000000nopqrstuvwxyz");
 
 		assertEditDistanceHirschberg(54, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
-		
+
 		assertEditDistanceHirschberg(51, "abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc", "abc");
 
 		assertEditDistanceHirschberg(25, "abcdefgxxxxxxxxxxxabcabcdefgxxxxxxx", "abcabcdefg");
 
 	}
-	
+
 	public void testEditScript() {
 		assertEditScript("", "");
 
@@ -104,7 +103,7 @@ public class LevenshteinTest extends TestCase {
 		assertEditScript("a", "bb");
 
 		assertEditScript("abcdefghijklmnopqrstuvwxyz", "abcdefhijklmnogpqrstuvwxyz");
-		
+
 		assertEditScript("abcdefghijklmnopqrstuvwxyz", "abcdefwxyz");
 
 		assertEditScript("abcdefghijklmnopqrstuvwxyz", "abcdefghijklm0000000000000000000000000000nopqrstuvwxyz");
@@ -114,21 +113,21 @@ public class LevenshteinTest extends TestCase {
 		assertEditScript("abcdefghijklm0000000000000000000000000000nopqrstuvwxyz", "abcdefghijklm0000000000000000000000000000nopqrstuvwxyz");
 
 		assertEditScript("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
-		
+
 		assertEditScript("abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc", "abc");
 
 		assertEditScript("abcdefgxxxxxxxxxxxabcabcdefgxxxxxxx", "abcabcdefg");
 
 	}
-	
+
 	public void testInternalEditDistance() {
-		IRangeComparator c1= new SequenceComparator("abcd"); 
+		IRangeComparator c1= new SequenceComparator("abcd");
 		IRangeComparator c2= new SequenceComparator("abcd");
-		
+
 		Levenshtein levenshtein= createLevenshtein(c1, c2);
 		LevenshteinTestHelper helper= new LevenshteinTestHelper(levenshtein);
 		helper.initRows();
-		
+
 		// full compare
 		helper.internalEditDistance(1, 4, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 4, 3, 2, 1, 0 }, helper.getPreviousRow()));
@@ -136,29 +135,29 @@ public class LevenshteinTest extends TestCase {
 		// partial compare
 		helper.internalEditDistance(1, 2, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 2, 1, 0, 1, 2 }, helper.getPreviousRow()));
-		
+
 		helper.internalEditDistance(3, 4, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 2, 2, 2, 3, 2 }, helper.getPreviousRow()));
-		
+
 		helper.internalEditDistance(1, 4, 1, 2);
 		assertEquals(4, helper.getPreviousRow()[0]);
 		assertEquals(3, helper.getPreviousRow()[1]);
 		assertEquals(2, helper.getPreviousRow()[2]);
-		
+
 		// empty right
 		helper.internalEditDistance(1, 0, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 0, 1, 2, 3, 4 }, helper.getPreviousRow()));
-		
+
 		// empty left
 		helper.internalEditDistance(1, 4, 1, 0);
 		assertEquals(4, helper.getPreviousRow()[0]);
-		
+
 		// empty both
 		helper.internalEditDistance(1, 0, 1, 0);
 		assertEquals(0, helper.getPreviousRow()[0]);
-		
+
 		// test insertion
-		c1= new SequenceComparator("a"); 
+		c1= new SequenceComparator("a");
 		c2= new SequenceComparator("ab");
 		levenshtein= createLevenshtein(c1, c2);
 		helper= new LevenshteinTestHelper(levenshtein);
@@ -170,19 +169,19 @@ public class LevenshteinTest extends TestCase {
 		helper.internalEditDistance(2, 2, 1, 1);
 		assertTrue(Arrays.equals(new int[] { 1, 1 }, helper.getPreviousRow()));
 	}
-	
+
 	protected Levenshtein createLevenshtein(IRangeComparator left, IRangeComparator right) {
 		return new Levenshtein(left, right);
 	}
 
 	public void testInternalReverseEditDistance() {
-		IRangeComparator c1= new SequenceComparator("abcd"); 
+		IRangeComparator c1= new SequenceComparator("abcd");
 		IRangeComparator c2= new SequenceComparator("abcd");
-		
+
 		Levenshtein levenshtein= createLevenshtein(c1, c2);
 		LevenshteinTestHelper helper= new LevenshteinTestHelper(levenshtein);
 		helper.initRows();
-		
+
 		// full compare
 		helper.internalReverseEditDistance(1, 4, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 0, 1, 2, 3, 4 }, helper.getPreviousRow()));
@@ -190,31 +189,31 @@ public class LevenshteinTest extends TestCase {
 		// partial compare
 		helper.internalReverseEditDistance(1, 2, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 2, 3, 2, 2, 2 }, helper.getPreviousRow()));
-		
+
 		helper.internalReverseEditDistance(3, 4, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 2, 1, 0, 1, 2 }, helper.getPreviousRow()));
-		
+
 		helper.internalReverseEditDistance(1, 4, 1, 2);
 		assertEquals(4, helper.getPreviousRow()[2]);
 		assertEquals(3, helper.getPreviousRow()[1]);
 		assertEquals(2, helper.getPreviousRow()[0]);
-		
+
 		// empty right
 		helper.internalReverseEditDistance(1, 0, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 4, 3, 2, 1, 0 }, helper.getPreviousRow()));
-		
+
 		// empty left
 		helper.internalReverseEditDistance(1, 4, 5, 4);
 		assertEquals(4, helper.getPreviousRow()[4]);
 		helper.internalReverseEditDistance(1, 4, 1, 0);
 		assertEquals(4, helper.getPreviousRow()[0]);
-		
+
 		// empty both
 		helper.internalReverseEditDistance(1, 0, 1, 0);
 		assertEquals(0, helper.getPreviousRow()[0]);
 
 		// test insertion
-		c1= new SequenceComparator("a"); 
+		c1= new SequenceComparator("a");
 		c2= new SequenceComparator("ab");
 		levenshtein= createLevenshtein(c1, c2);
 		helper= new LevenshteinTestHelper(levenshtein);
@@ -226,12 +225,12 @@ public class LevenshteinTest extends TestCase {
 		helper.internalReverseEditDistance(2, 2, 1, 1);
 		assertTrue(Arrays.equals(new int[] { 1, 1 }, helper.getPreviousRow()));
 	}
-	
+
 	public void testEditScriptHirschberg() {
 		assertEditScriptHirschberg("abc", "abc");
-		
+
 		assertEditScriptHirschberg("a", "b");
-		
+
 		assertEditScriptHirschberg("", "");
 
 		assertEditScriptHirschberg("a", "");
@@ -241,7 +240,7 @@ public class LevenshteinTest extends TestCase {
 		assertEditScriptHirschberg("a", "bb");
 
 		assertEditScriptHirschberg("abcdefghijklmnopqrstuvwxyz", "abcdefhijklmnogpqrstuvwxyz");
-		
+
 		assertEditScriptHirschberg("abcdefghijklmnopqrstuvwxyz", "abcdefwxyz");
 
 		assertEditScriptHirschberg("abcdefghijklmnopqrstuvwxyz", "abcdefghijklm0000000000000000000000000000nopqrstuvwxyz");
@@ -251,20 +250,20 @@ public class LevenshteinTest extends TestCase {
 		assertEditScriptHirschberg("abcdefghijklm0000000000000000000000000000nopqrstuvwxyz", "abcdefghijklm0000000000000000000000000000nopqrstuvwxyz");
 
 		assertEditScriptHirschberg("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
-		
+
 		assertEditScriptHirschberg("abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc", "abc");
 
 		assertEditScriptHirschberg("abcdefgxxxxxxxxxxxabcabcdefgxxxxxxx", "abcabcdefg");
 
 	}
-	
+
 	private void assertEditScript(String s1, String s2) {
 		SequenceComparator sc1= new SequenceComparator(s1);
 		SequenceComparator sc2= new SequenceComparator(s2);
 		RangeDifference[] expected= RangeDifferencer.findDifferences(sc1, sc2);
 		Levenshtein levenshtein= createLevenshtein(sc1,sc2);
 		RangeDifference[] tested= levenshtein.editScript();
-		
+
 		assertTrue(Arrays.equals(expected, tested));
 	}
 
@@ -274,7 +273,7 @@ public class LevenshteinTest extends TestCase {
 		RangeDifference[] expected= RangeDifferencer.findDifferences(sc1, sc2);
 		Levenshtein levenshtein= createLevenshtein(sc1,sc2);
 		RangeDifference[] tested= levenshtein.editScriptHirschberg();
-		
+
 		assertTrue(Arrays.equals(expected, tested));
 	}
 
@@ -309,8 +308,8 @@ public class LevenshteinTest extends TestCase {
 
 class SequenceComparator implements IRangeComparator {
 	private final CharSequence fSequence;
-	
-	
+
+
 	public SequenceComparator(CharSequence string) {
 		Assert.isNotNull(string);
 		fSequence= string;
@@ -327,9 +326,9 @@ class SequenceComparator implements IRangeComparator {
 	public boolean skipRangeComparison(int length, int maxLength, IRangeComparator other) {
 		return false;
 	}
-	
+
 	public String toString() {
 		return "SequenceComparator [" + fSequence + "]";
 	}
-	
+
 }
diff --git a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/quickdiff/tests/LevenshteinTestHelper.java b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/quickdiff/tests/LevenshteinTestHelper.java
index fee8b4bda44..10f14ad50c3 100644
--- a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/quickdiff/tests/LevenshteinTestHelper.java
+++ b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/quickdiff/tests/LevenshteinTestHelper.java
@@ -17,7 +17,7 @@ import org.eclipse.ui.internal.texteditor.quickdiff.compare.rangedifferencer.Lev
 
 /**
  * Accessor for package private methods in Levenshtein.
- * 
+ *
  * @since 3.1
  */
 public final class LevenshteinTestHelper {
diff --git a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/quickdiff/tests/OptimizedLevenshteinTest.java b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/quickdiff/tests/OptimizedLevenshteinTest.java
index 2d4a3ee0481..ac6eda3200a 100644
--- a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/quickdiff/tests/OptimizedLevenshteinTest.java
+++ b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/quickdiff/tests/OptimizedLevenshteinTest.java
@@ -30,15 +30,15 @@ public class OptimizedLevenshteinTest extends TestCase {
 		helper.setOptimizedCellComputer();
 		return ls;
 	}
-	
+
 	public void testInternalEditDistance() {
-		IRangeComparator c1= new SequenceComparator("abcd"); 
+		IRangeComparator c1= new SequenceComparator("abcd");
 		IRangeComparator c2= new SequenceComparator("abcd");
-		
+
 		Levenshtein levenshtein= createLevenshtein(c1, c2);
 		LevenshteinTestHelper helper= new LevenshteinTestHelper(levenshtein);
 		helper.initRows();
-		
+
 		// full compare
 		helper.internalEditDistance(1, 4, 1, 4);
 		assertTrue(Arrays.equals(new int[] { SKIP, SKIP, SKIP, SKIP, 0 }, helper.getPreviousRow()));
@@ -46,29 +46,29 @@ public class OptimizedLevenshteinTest extends TestCase {
 		// partial compare
 		helper.internalEditDistance(1, 2, 1, 4);
 		assertTrue(Arrays.equals(new int[] { SKIP, SKIP, 0, 1, 2 }, helper.getPreviousRow()));
-		
+
 		helper.internalEditDistance(3, 4, 1, 4);
 		assertTrue(Arrays.equals(new int[] { SKIP, SKIP, SKIP, SKIP, 2 }, helper.getPreviousRow()));
-		
+
 		helper.internalEditDistance(1, 4, 1, 2);
 		assertEquals(SKIP, helper.getPreviousRow()[0]);
 		assertEquals(SKIP, helper.getPreviousRow()[1]);
 		assertEquals(2, helper.getPreviousRow()[2]);
-		
+
 		// empty right
 		helper.internalEditDistance(1, 0, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 0, 1, 2, 3, 4 }, helper.getPreviousRow()));
-		
+
 		// empty left
 		helper.internalEditDistance(1, 4, 1, 0);
 		assertEquals(4, helper.getPreviousRow()[0]);
-		
+
 		// empty both
 		helper.internalEditDistance(1, 0, 1, 0);
 		assertEquals(0, helper.getPreviousRow()[0]);
-		
+
 		// test insertion
-		c1= new SequenceComparator("a"); 
+		c1= new SequenceComparator("a");
 		c2= new SequenceComparator("ab");
 		levenshtein= createLevenshtein(c1, c2);
 		helper= new LevenshteinTestHelper(levenshtein);
@@ -80,15 +80,15 @@ public class OptimizedLevenshteinTest extends TestCase {
 		helper.internalEditDistance(2, 2, 1, 1);
 		assertTrue(Arrays.equals(new int[] { SKIP, 1 }, helper.getPreviousRow()));
 	}
-	
+
 	public void testInternalReverseEditDistance() {
-		IRangeComparator c1= new SequenceComparator("abcd"); 
+		IRangeComparator c1= new SequenceComparator("abcd");
 		IRangeComparator c2= new SequenceComparator("abcd");
-		
+
 		Levenshtein levenshtein= createLevenshtein(c1, c2);
 		LevenshteinTestHelper helper= new LevenshteinTestHelper(levenshtein);
 		helper.initRows();
-		
+
 		// full compare
 		helper.internalReverseEditDistance(1, 4, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 0, SKIP, SKIP, SKIP, SKIP }, helper.getPreviousRow()));
@@ -96,31 +96,31 @@ public class OptimizedLevenshteinTest extends TestCase {
 		// partial compare
 		helper.internalReverseEditDistance(1, 2, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 2, SKIP, SKIP, SKIP, SKIP }, helper.getPreviousRow()));
-		
+
 		helper.internalReverseEditDistance(3, 4, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 2, 1, 0, SKIP, SKIP }, helper.getPreviousRow()));
-		
+
 		helper.internalReverseEditDistance(1, 4, 1, 2);
 		assertEquals(SKIP, helper.getPreviousRow()[2]);
 		assertEquals(SKIP, helper.getPreviousRow()[1]);
 		assertEquals(2, helper.getPreviousRow()[0]);
-		
+
 		// empty right
 		helper.internalReverseEditDistance(1, 0, 1, 4);
 		assertTrue(Arrays.equals(new int[] { 4, 3, 2, 1, 0 }, helper.getPreviousRow()));
-		
+
 		// empty left
 		helper.internalReverseEditDistance(1, 4, 5, 4);
 		assertEquals(4, helper.getPreviousRow()[4]);
 		helper.internalReverseEditDistance(1, 4, 1, 0);
 		assertEquals(4, helper.getPreviousRow()[0]);
-		
+
 		// empty both
 		helper.internalReverseEditDistance(1, 0, 1, 0);
 		assertEquals(0, helper.getPreviousRow()[0]);
 
 		// test insertion
-		c1= new SequenceComparator("a"); 
+		c1= new SequenceComparator("a");
 		c2= new SequenceComparator("ab");
 		levenshtein= createLevenshtein(c1, c2);
 		helper= new LevenshteinTestHelper(levenshtein);
@@ -132,7 +132,7 @@ public class OptimizedLevenshteinTest extends TestCase {
 		helper.internalReverseEditDistance(2, 2, 1, 1);
 		assertTrue(Arrays.equals(new int[] { 1, SKIP }, helper.getPreviousRow()));
 	}
-	
+
 
 
 }
diff --git a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/FindReplaceDialogTest.java b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/FindReplaceDialogTest.java
index 1f06ec9e577..99875b0c829 100644
--- a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/FindReplaceDialogTest.java
+++ b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/FindReplaceDialogTest.java
@@ -24,25 +24,25 @@ import org.eclipse.ui.PlatformUI;
 
 /**
  * Tests the FindReplaceDialog.
- * 
+ *
  * @since 3.1
  */
 public class FindReplaceDialogTest extends TestCase {
-	
+
 	private Accessor fFindReplaceDialog;
-	
-	
+
+
 	public FindReplaceDialogTest(String name) {
 		super(name);
 	}
-	
-	
+
+
 	protected void setUp() {
 		Shell shell= PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
 		fFindReplaceDialog= new Accessor("org.eclipse.ui.texteditor.FindReplaceDialog", getClass().getClassLoader(), new Object[] {shell});
 		fFindReplaceDialog.invoke("create", null);
 	}
-	
+
 	public static Test suite() {
 		TestSuite suite= new TestSuite();
 		suite.addTest(new FindReplaceDialogTest("testInitialButtonState"));
@@ -50,12 +50,12 @@ public class FindReplaceDialogTest extends TestCase {
 		suite.addTest(new FindReplaceDialogTest("testDisableWholeWordIfNotWord"));
 		return suite;
 	}
-	
+
 	protected void tearDown () {
 		fFindReplaceDialog.invoke("close", null);
 		fFindReplaceDialog= null;
 	}
-	
+
 	public void testInitialButtonState() {
 		Boolean value;
 		value= (Boolean)fFindReplaceDialog.invoke("isWholeWordSearch", null);
@@ -73,7 +73,7 @@ public class FindReplaceDialogTest extends TestCase {
 		checkbox= (Button)fFindReplaceDialog.get("fWholeWordCheckBox");
 		assertFalse(checkbox.isEnabled()); // there's no word in the Find field
 	}
-	
+
 	public void testDisableWholeWordIfRegEx() {
 		Combo findField= (Combo)fFindReplaceDialog.get("fFindField");
 		findField.setText("word");
@@ -83,7 +83,7 @@ public class FindReplaceDialogTest extends TestCase {
 
 		assertTrue(isRegExCheckBox.isEnabled());
 		assertTrue(wholeWordCheckbox.isEnabled());
-		
+
 		fFindReplaceDialog.set("fIsTargetSupportingRegEx", true);
 		isRegExCheckBox.setSelection(true);
 		wholeWordCheckbox.setSelection(true);
@@ -91,11 +91,11 @@ public class FindReplaceDialogTest extends TestCase {
 
 		assertTrue(isRegExCheckBox.isEnabled());
 		assertFalse(wholeWordCheckbox.isEnabled());
-		
+
 		// XXX: enable once https://bugs.eclipse.org/bugs/show_bug.cgi?id=72462 has been fixed
 //		assertFalse(wholeWordCheckbox.getSelection());
 	}
-	
+
 	public void testDisableWholeWordIfNotWord() {
 		Combo findField= (Combo)fFindReplaceDialog.get("fFindField");
 		Button isRegExCheckBox= (Button)fFindReplaceDialog.get("fIsRegExCheckBox");
@@ -105,7 +105,7 @@ public class FindReplaceDialogTest extends TestCase {
 		isRegExCheckBox.setSelection(false);
 		wholeWordCheckbox.setSelection(true);
 		fFindReplaceDialog.invoke("updateButtonState", null);
-		
+
 		findField.setText("word");
 		assertTrue(isRegExCheckBox.isEnabled());
 		assertTrue(wholeWordCheckbox.isEnabled());
@@ -114,7 +114,7 @@ public class FindReplaceDialogTest extends TestCase {
 		findField.setText("no word");
 		assertTrue(isRegExCheckBox.isEnabled());
 		assertFalse(wholeWordCheckbox.isEnabled());
-		
+
 		// XXX: enable once https://bugs.eclipse.org/bugs/show_bug.cgi?id=72462 has been fixed
 //		assertFalse(wholeWordCheckbox.getSelection());
 	}
diff --git a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/HippieCompletionTest.java b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/HippieCompletionTest.java
index 612cd4ca01f..46b27d159f5 100644
--- a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/HippieCompletionTest.java
+++ b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/HippieCompletionTest.java
@@ -27,82 +27,82 @@ import org.eclipse.ui.internal.texteditor.HippieCompletionEngine;
 
 /**
  * Tests for the Hippie completion action of the text editor.
- * 
+ *
  * @author Genady Beryozkin, me@genady.org
  */
 public class HippieCompletionTest extends TestCase {
-	
+
 	IDocument[] documents;
 	private HippieCompletionEngine fEngine;
-	
+
 	public HippieCompletionTest(String name) {
 		super(name);
 	}
-	
+
 	/*
 	 * @see junit.framework.TestCase#setUp()
 	 */
 	protected void setUp() throws Exception {
 		documents= new IDocument[5];
-		documents[0]= new Document("package ui.TestPackage;\n" + 
-				"\n" + 
-				"/**\n" + 
+		documents[0]= new Document("package ui.TestPackage;\n" +
+				"\n" +
+				"/**\n" +
 				" * This is a testing class that tests the hippie completion engine.\n" +
-				" * it has a simple main with a print method\n" + 
-				" */\n" + 
-				"public class TestClass1 {\n" + 
-				"\n" + 
-				"    public static void main(String[] args) {\n" + 
-				"        System.out.println(\"I will be printing Hello world!\");\n" + 
-				"    }\n" + 
+				" * it has a simple main with a print method\n" +
+				" */\n" +
+				"public class TestClass1 {\n" +
+				"\n" +
+				"    public static void main(String[] args) {\n" +
+				"        System.out.println(\"I will be printing Hello world!\");\n" +
+				"    }\n" +
 				"}");
-		documents[1]= new Document("This is a simple text file\n" + 
+		documents[1]= new Document("This is a simple text file\n" +
 				"with some testssome test that is also used in the completion engine tests");
-		
-		documents[2]= new Document("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + 
-				"<plugin\n" + 
-				"   id=\"org.eclipse.ui.workbench.texteditor.tests\"\n" + 
-				"   name=\"%Plugin.name\"\n" + 
-				"   version=\"3.1.0\"\n" + 
-				"   provider-name=\"%Plugin.providerName\">\n" + 
-				"\n" + 
-				"   <runtime>\n" + 
-				"      <library name=\"workbenchtexteditortests.jar\">\n" + 
-				"         <export name=\"*\"/>\n" + 
-				"      </library>\n" + 
-				"   </runtime>\n" + 
-				"   \n" + 
-				"   <requires>\n" + 
-				"      <import plugin=\"org.eclipse.core.runtime.compatibility\"/>\n" + 
-				"      <import plugin=\"org.junit\"/>\n" + 
-				"      <import plugin=\"org.eclipse.text.tests\"/>\n" + 
-				"      <import plugin=\"org.eclipse.jface.text\"/>\n" + 
-				"      <import plugin=\"org.eclipse.ui.workbench.texteditor\"/>\n" + 
-				"      <import plugin=\"org.eclipse.ui\"/>\n" + 
-				"   </requires>\n" + 
-				"   \n" + 
-				"</plugin>\n" + 
+
+		documents[2]= new Document("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
+				"<plugin\n" +
+				"   id=\"org.eclipse.ui.workbench.texteditor.tests\"\n" +
+				"   name=\"%Plugin.name\"\n" +
+				"   version=\"3.1.0\"\n" +
+				"   provider-name=\"%Plugin.providerName\">\n" +
+				"\n" +
+				"   <runtime>\n" +
+				"      <library name=\"workbenchtexteditortests.jar\">\n" +
+				"         <export name=\"*\"/>\n" +
+				"      </library>\n" +
+				"   </runtime>\n" +
+				"   \n" +
+				"   <requires>\n" +
+				"      <import plugin=\"org.eclipse.core.runtime.compatibility\"/>\n" +
+				"      <import plugin=\"org.junit\"/>\n" +
+				"      <import plugin=\"org.eclipse.text.tests\"/>\n" +
+				"      <import plugin=\"org.eclipse.jface.text\"/>\n" +
+				"      <import plugin=\"org.eclipse.ui.workbench.texteditor\"/>\n" +
+				"      <import plugin=\"org.eclipse.ui\"/>\n" +
+				"   </requires>\n" +
+				"   \n" +
+				"</plugin>\n" +
 				"");
-		
-		documents[3]= new Document("###############################################################################\n" + 
-				"# Copyright (c) 2000, 2004 IBM Corporation and others.\n" + 
-				"# All rights reserved. This program and the accompanying materials \n" + 
-				"# are made available under the terms of the Eclipse Public License v1.0\n" + 
-				"# which accompanies this distribution, and is available at\n" + 
-				"# http://www.eclipse.org/legal/epl-v10.html\n" + 
-				"# \n" + 
-				"# Contributors:\n" + 
-				"#     IBM Corporation - initial API and implementation\n" + 
-				"###############################################################################\n" + 
-				"bin.includes= plugin.xml,\\\n" + 
-				"               plugin.properties,\\\n" + 
-				"               test.xml,\\\n" + 
-				"               about.html,\\\n" + 
-				"               *.jar\n" + 
-				"\n" + 
-				"src.includes= about.html\n" + 
-				"               \n" + 
-				"source.workbenchtexteditortests.jar= src/\n" + 
+
+		documents[3]= new Document("###############################################################################\n" +
+				"# Copyright (c) 2000, 2004 IBM Corporation and others.\n" +
+				"# All rights reserved. This program and the accompanying materials \n" +
+				"# are made available under the terms of the Eclipse Public License v1.0\n" +
+				"# which accompanies this distribution, and is available at\n" +
+				"# http://www.eclipse.org/legal/epl-v10.html\n" +
+				"# \n" +
+				"# Contributors:\n" +
+				"#     IBM Corporation - initial API and implementation\n" +
+				"###############################################################################\n" +
+				"bin.includes= plugin.xml,\\\n" +
+				"               plugin.properties,\\\n" +
+				"               test.xml,\\\n" +
+				"               about.html,\\\n" +
+				"               *.jar\n" +
+				"\n" +
+				"src.includes= about.html\n" +
+				"               \n" +
+				"source.workbenchtexteditortests.jar= src/\n" +
 				"");
 		documents[4]= new Document("/**\n" +
 				" * This class tests the hippie completion functionality.\n" +
@@ -120,40 +120,40 @@ public class HippieCompletionTest extends TestCase {
 				"\t\tString $arabic\u20AAWord= \"\u0628\u064E\u0627\u0628\u0650\";\n" + // shekel (israeli) currency symbol + arabic word
 				"\t\tString \u0628\u0627\u0628= \"\u044D\u0442\";\n" + // arabic var, russian string
 				"\t\tint \u20A31= 3;\n" + // frank currency symbol
-				"\t\tint \u00A3\u0661\u0662\u0663= \u20A31 + \u05DE\u05D7;\n" + // pound, arabic digits 1-3, partial hebrew word  
+				"\t\tint \u00A3\u0661\u0662\u0663= \u20A31 + \u05DE\u05D7;\n" + // pound, arabic digits 1-3, partial hebrew word
 				"\t\tint a\u0300\u0301b= 18;\n" + // combining diactritical marks
 				"\t\t}\n" +
 				"\t\t\n" +
 				"\tpublic void \u05D4\u05D4\u05E9(int \u0441\u0430\u043C) {\n" + // hebrew word prexif, russian word prefix
 				"\t\tString \u043B\u0443\u0447\u0448= \"\u05D1\u05D5\u05D3\u05E7\";\n" +
-				"\t\tchar \u20AA129;\n" + // shekel (israeli) currency 
+				"\t\tchar \u20AA129;\n" + // shekel (israeli) currency
 				"\t}\n" +
 				"}");
-		
+
 		fEngine= new HippieCompletionEngine();
 	}
-	
+
 	public void testSearchBackwards1() {
 		try {
-			List list= fEngine.getCompletionsBackwards(documents[0], 
+			List list= fEngine.getCompletionsBackwards(documents[0],
 					"pri", documents[0].get().indexOf("println") + 10);
 			assertEquals(list.size(), 2);
 			assertEquals(list.get(0), "ntln");
 			assertEquals(list.get(1), "nt");
-			
-			list= fEngine.getCompletionsBackwards(documents[0], 
+
+			list= fEngine.getCompletionsBackwards(documents[0],
 					"pri", documents[0].getLength());
 			assertEquals(list.size(), 3);
 			assertEquals(list.get(0), "nting");
 			assertEquals(list.get(1), "ntln");
 			assertEquals(list.get(2), "nt");
-			
-			list= fEngine.getCompletionsBackwards(documents[0], 
+
+			list= fEngine.getCompletionsBackwards(documents[0],
 					"pri", documents[0].get().indexOf("println") + 1);
 			assertEquals(list.size(), 1);
             assertEquals(list.get(0), "nt");
 
-			list= fEngine.getCompletionsBackwards(documents[0], 
+			list= fEngine.getCompletionsBackwards(documents[0],
 					"pa", 2);
 			assertEquals(list.size(), 0);
 
@@ -161,52 +161,52 @@ public class HippieCompletionTest extends TestCase {
 			assertTrue("Got out of document bounds", false);
 		}
 	}
-	
+
 	public void testSearchBackwards2() {
 		try {
-			List list= fEngine.getCompletionsBackwards(documents[2], 
+			List list= fEngine.getCompletionsBackwards(documents[2],
 					"plugi", documents[2].getLength());
 			assertEquals(8, list.size());
 			list= fEngine.makeUnique(list);
 			assertEquals(1, list.size());
 			assertEquals("n", list.get(0));
-			
-			list= fEngine.getCompletionsBackwards(documents[2], 
+
+			list= fEngine.getCompletionsBackwards(documents[2],
 					"plugin", documents[2].getLength());
 			assertEquals(0, list.size()); // empty completions discarded
-			
+
 		} catch (BadLocationException e) {
 			assertTrue("Got out of document bounds", false);
 		}
 	}
-	
+
     public void testSearchBackwards3() {
         try {
-            List list= fEngine.getCompletionsBackwards(documents[1], 
+            List list= fEngine.getCompletionsBackwards(documents[1],
                     "test", documents[1].getLength());
             assertEquals("Number of backwards suggestions does not match", 2, list.size());
-            list= fEngine.getCompletionsBackwards(documents[1], 
+            list= fEngine.getCompletionsBackwards(documents[1],
                     "tests", documents[1].getLength());
             assertEquals("Number of backwards suggestions does not match", 1, list.size());
 
-            list= fEngine.getCompletionsBackwards(documents[1], 
+            list= fEngine.getCompletionsBackwards(documents[1],
                     "test", documents[1].getLength() - 1);
             assertEquals("Number of backwards suggestions does not match", 1, list.size());
         } catch (BadLocationException e) {
             assertTrue("Got out of document bounds", false);
         }
     }
-	
+
 	public void testSearch() {
 		ArrayList docsList= new ArrayList(Arrays.asList(this.documents));
 		List result= createSuggestions("te", docsList);
 		assertEquals("Number of completions does not match", 15, result.size());
 		result= fEngine.makeUnique(result);
 		assertEquals("Number of completions does not match", 7, result.size());
-		
+
 		result= createSuggestions("Plug", docsList);
 		assertEquals("Number of completions does not match", 2, result.size());
-		
+
 		result= createSuggestions("p", docsList);
 		assertEquals("Number of completions does not match", 23, result.size());
 		result= fEngine.makeUnique(result);
@@ -222,58 +222,58 @@ public class HippieCompletionTest extends TestCase {
 		assertEquals("Incorrect completion", "rogram", result.get(8));
 		assertEquals("Incorrect completion", "roperties", result.get(9));
 	}
-	
+
 	public void testSearch2() {
 		ArrayList docsList= new ArrayList(Arrays.asList(this.documents));
 		List result= createSuggestions("printe", docsList);
 		assertEquals("Number of completions does not match", 0, result.size());
-		
+
 		result= createSuggestions("s", docsList);
 		assertEquals("Number of completions does not match", 8, result.size());
-		
+
 		result= createSuggestions("pack", documents[0]);
 		assertEquals("Number of completions does not match", 1, result.size());
 	}
-	
-	
+
+
 	public void testForwardSearch() {
 		try {
-			List result= fEngine.getCompletionsForward(documents[0], 
+			List result= fEngine.getCompletionsForward(documents[0],
 					"cl", documents[0].get().indexOf("cl"), true);
 			assertEquals(2, result.size());
-			
-			result= fEngine.getCompletionsForward(documents[0], 
+
+			result= fEngine.getCompletionsForward(documents[0],
 					"cl", documents[0].get().indexOf("cl") + 1, true);
 			assertEquals(1, result.size());
 
-			result= fEngine.getCompletionsForward(documents[1], 
+			result= fEngine.getCompletionsForward(documents[1],
 					"Thi", 0, true);
 			assertEquals(1, result.size());
 
-			result= fEngine.getCompletionsForward(documents[1], 
+			result= fEngine.getCompletionsForward(documents[1],
 					"Thi", 1, true);
 			assertEquals(0, result.size());
 		} catch (BadLocationException e) {
 			assertTrue("Got out of document bounds", false);
 		}
 	}
-	
+
 	public void testForwardSearchInternational() {
 		List result;
 		try {
-			result= fEngine.getCompletionsForward(documents[4], 
+			result= fEngine.getCompletionsForward(documents[4],
 					"$", documents[4].get().indexOf('$'), true);
-			assertEquals(2, result.size());		
+			assertEquals(2, result.size());
 			assertEquals("arabic\u20AAWord", result.get(0));
 			assertEquals("arabic\u20ACDigits", result.get(1));
 
-			result= fEngine.getCompletionsForward(documents[4], 
+			result= fEngine.getCompletionsForward(documents[4],
 					"$", documents[4].get().indexOf('$'), false);
-			assertEquals(2, result.size());		
+			assertEquals(2, result.size());
 			assertEquals("arabic\u20ACDigits", result.get(0));
 			assertEquals("arabic\u20AAWord", result.get(1));
 
-			result= fEngine.getCompletionsForward(documents[4], 
+			result= fEngine.getCompletionsForward(documents[4],
 					"$", documents[4].get().indexOf('$') + 1, true);
 			assertEquals(1, result.size());
 			assertEquals("arabic\u20AAWord", result.get(0));
@@ -281,23 +281,23 @@ public class HippieCompletionTest extends TestCase {
 			assertTrue("Got out of document bounds", false);
 		}
 	}
-	
-	
+
+
 	public void testPrefix() {
 		try {
-			String prefix= fEngine.getPrefixString(documents[0], 
+			String prefix= fEngine.getPrefixString(documents[0],
 					documents[0].get().indexOf("testing") + 3);
 			assertEquals(prefix, "tes");
-			
-			prefix= fEngine.getPrefixString(documents[0], 
+
+			prefix= fEngine.getPrefixString(documents[0],
 					documents[0].get().indexOf("public") + 4);
 			assertEquals(prefix, "publ");
 
-			prefix= fEngine.getPrefixString(documents[0], 
+			prefix= fEngine.getPrefixString(documents[0],
 					documents[0].get().indexOf("println") + 7);
 			assertEquals(prefix, "println");
 
-			prefix= fEngine.getPrefixString(documents[0], 
+			prefix= fEngine.getPrefixString(documents[0],
 					documents[0].get().indexOf("println") + 8);
 			assertEquals(prefix, null);
 
@@ -309,50 +309,50 @@ public class HippieCompletionTest extends TestCase {
 
 			prefix= fEngine.getPrefixString(documents[1], documents[1].getLength());
 			assertEquals(prefix, "tests");
-			
-			prefix= fEngine.getPrefixString(documents[3], 
+
+			prefix= fEngine.getPrefixString(documents[3],
 					documents[3].get().indexOf("Copyright") - 2);
 			assertEquals(prefix, null);
-			
-			prefix= fEngine.getPrefixString(documents[4], 
+
+			prefix= fEngine.getPrefixString(documents[4],
 					documents[4].get().indexOf("IDE") + 2);
 			assertEquals(prefix, "ID");
 
-			prefix= fEngine.getPrefixString(documents[4], 
+			prefix= fEngine.getPrefixString(documents[4],
 					documents[4].get().indexOf("$arabic\u20ACDigits") + 8);
 			assertEquals(prefix, "$arabic\u20AC");
-			
-			prefix= fEngine.getPrefixString(documents[4], 
+
+			prefix= fEngine.getPrefixString(documents[4],
 					documents[4].get().indexOf("$arabic\u20AAWord") + 8);
 			assertEquals(prefix, "$arabic\u20AA");
-			
-			prefix= fEngine.getPrefixString(documents[4], 
+
+			prefix= fEngine.getPrefixString(documents[4],
 					documents[4].get().indexOf("\u00A3\u0661\u0662\u0663") + 3);
 			assertEquals(prefix, "\u00A3\u0661\u0662");
-			
-			prefix= fEngine.getPrefixString(documents[4], 
+
+			prefix= fEngine.getPrefixString(documents[4],
 					documents[4].get().indexOf("a\u0300\u0301b") + 3);
 			assertEquals(prefix, "a\u0300\u0301");
 
-			prefix= fEngine.getPrefixString(documents[4], 
+			prefix= fEngine.getPrefixString(documents[4],
 					documents[4].get().indexOf("\u0667\u0668\u0669\u0660") + 2);
 			assertEquals(prefix, "\u0667\u0668");
-		
+
 		} catch (BadLocationException e) {
 			assertTrue("Got out of document bounds", false);
 		}
 	}
-	
+
 	public void testInternational() {
 		IDocument intlDoc= documents[4];
-		
+
 		List result= createSuggestions("\u05D4", intlDoc); // hebrew letter heh
 		assertEquals("Number of completions does not match", 4, result.size());
 		assertEquals(result.get(0), "\u05DE\u05D7\u05DC\u05E7\u05D4");
 		assertEquals(result.get(1), "\u05D6\u05D5");
 		assertEquals(result.get(2), "\u05D4\u05E9\u05DC\u05DE\u05D5\u05EA");
 		assertEquals(result.get(3), "\u05D4\u05E9");
-		
+
 		result= createSuggestions("\u0661", intlDoc); // arabic digit "1"
 		assertEquals("Number of completions does not match", 1, result.size());
 		assertEquals(result.get(0), "\u0662\u0663\u0664\u0665\u0666");
@@ -380,7 +380,7 @@ public class HippieCompletionTest extends TestCase {
 		assertEquals(result.get(0), "\u05D3\u05E7\u05EA");
 		assertEquals(result.get(1), "\u05D3\u05E7");
 
-		result= createSuggestions("a", intlDoc); 
+		result= createSuggestions("a", intlDoc);
 		assertEquals("Number of completions does not match", 4, result.size());
 		assertEquals(result.get(0), "n");
 		assertEquals(result.get(1), "rabic");
@@ -404,45 +404,45 @@ public class HippieCompletionTest extends TestCase {
 		result= createSuggestions("\u00A3", intlDoc);  // pound currency sign
 		assertEquals("Number of completions does not match", 1, result.size());
 		assertEquals(result.get(0), "\u0661\u0662\u0663");
-		
+
 		result= createSuggestions("\u00A5", intlDoc);  // yen currency sign
-		assertEquals("Number of completions does not match", 0, result.size());		
+		assertEquals("Number of completions does not match", 0, result.size());
 	}
-	
-	
+
+
 	public void testInternationalBackwards() {
 		IDocument intlDoc= documents[4];
 		try {
-			List list= fEngine.getCompletionsBackwards(intlDoc, 
+			List list= fEngine.getCompletionsBackwards(intlDoc,
 					"\u043B\u0443", intlDoc.get().indexOf("129"));
 			assertEquals(2, list.size());
 			assertEquals(list.get(0), "\u0447\u0448");
 			assertEquals(list.get(1), "\u0447\u0448\u0438\u0439");
 
-			list= fEngine.getCompletionsBackwards(intlDoc, 
+			list= fEngine.getCompletionsBackwards(intlDoc,
 					"\u05DE", intlDoc.get().lastIndexOf('+'));
 			assertEquals(2, list.size());
 			assertEquals(list.get(0), "\u05D7");
 			assertEquals(list.get(1), "\u05E0\u05D2\u05E0\u05D5\u05DF");
 
-			list= fEngine.getCompletionsBackwards(intlDoc, 
+			list= fEngine.getCompletionsBackwards(intlDoc,
 					"\u0667", intlDoc.get().indexOf("\u2021\u0667") + 1);
 			assertEquals(0, list.size());
-			
-			list= fEngine.getCompletionsBackwards(intlDoc, 
+
+			list= fEngine.getCompletionsBackwards(intlDoc,
 					"\u0628", intlDoc.get().lastIndexOf("\u0628"));
 			assertEquals(1, list.size());
 			assertEquals(list.get(0), "\u064E\u0627\u0628\u0650");
-			
+
 		} catch (BadLocationException e) {
 			assertTrue("Got out of document bounds", false);
 		}
 	}
-	
+
 	public static Test suite() {
-		return new TestSuite(HippieCompletionTest.class); 
+		return new TestSuite(HippieCompletionTest.class);
 	}
-	
+
 	private List createSuggestions(String prefix, IDocument doc) {
 		return createSuggestions(prefix, Arrays.asList(new IDocument[]{doc}));
 	}
@@ -459,5 +459,5 @@ public class HippieCompletionTest extends TestCase {
 		}
 		return results;
 	}
-	
+
 }
diff --git a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/WorkbenchTextEditorTestSuite.java b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/WorkbenchTextEditorTestSuite.java
index 86867e2e561..ab0f0cc251f 100644
--- a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/WorkbenchTextEditorTestSuite.java
+++ b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/WorkbenchTextEditorTestSuite.java
@@ -21,7 +21,7 @@ import org.eclipse.ui.workbench.texteditor.tests.rulers.RulerTestSuite;
 
 /**
  * Test Suite for org.eclipse.ui.workbench.texteditor.
- * 
+ *
  * @since 3.0
  */
 public class WorkbenchTextEditorTestSuite extends TestSuite {
@@ -36,7 +36,7 @@ public class WorkbenchTextEditorTestSuite extends TestSuite {
         suite.addTest(ChangeRegionTest.suite());
         suite.addTest(RulerTestSuite.suite());
         suite.addTest(HunkComputerTest.suite());
-        
+
 		//$JUnit-END$
 		return suite;
 	}
diff --git a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/ChangeRegionTest.java b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/ChangeRegionTest.java
index 2dc179925fc..639ef54924a 100644
--- a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/ChangeRegionTest.java
+++ b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/ChangeRegionTest.java
@@ -19,20 +19,20 @@ import junit.framework.TestSuite;
 
 import org.eclipse.swt.graphics.RGB;
 
+import org.eclipse.jface.internal.text.revisions.ChangeRegion;
+import org.eclipse.jface.internal.text.revisions.Hunk;
+
 import org.eclipse.jface.text.revisions.Revision;
 import org.eclipse.jface.text.source.ILineRange;
 import org.eclipse.jface.text.source.LineRange;
 
-import org.eclipse.jface.internal.text.revisions.ChangeRegion;
-import org.eclipse.jface.internal.text.revisions.Hunk;
-
 /**
- * 
+ *
  * @since 3.2
  */
 public class ChangeRegionTest extends TestCase {
 	public static Test suite() {
-		return new TestSuite(ChangeRegionTest.class); 
+		return new TestSuite(ChangeRegionTest.class);
 	}
 
 	public static final class TestRevision extends Revision {
@@ -54,7 +54,7 @@ public class ChangeRegionTest extends TestCase {
 	}
 
 	private Revision fRevision;
-	
+
 	/*
 	 * @see junit.framework.TestCase#setUp()
 	 */
@@ -68,32 +68,32 @@ public class ChangeRegionTest extends TestCase {
 			fail();
 		} catch (Exception e) {
 		}
-		
+
 		try {
 			new ChangeRegion(null, new LineRange(12, 3));
 			fail();
 		} catch (Exception e) {
 		}
-		
+
 		try {
 			new ChangeRegion(null, null);
 			fail();
 		} catch (Exception e) {
 		}
-		
+
 		ChangeRegion r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		assertEquals(fRevision, r.getRevision());
 		RangeUtil.assertEqualRange(new LineRange(12, 3), (ILineRange) r.getAdjustedRanges().get(0));
 		RangeUtil.assertEqualRange(new LineRange(12, 3), r.getAdjustedCoverage());
 	}
-	
+
 	public void testHunkAfter() throws Exception {
 		ChangeRegion r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		List before= RangeUtil.deepClone(r.getAdjustedRanges());
 		r.adjustTo(new Hunk(16, 3, 2));
 		RangeUtil.assertEqualRanges(before, r.getAdjustedRanges());
 		RangeUtil.assertEqualRange((ILineRange) before.get(0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		before= RangeUtil.deepClone(r.getAdjustedRanges());
 		r.adjustTo(new Hunk(16, -33, 2));
@@ -107,27 +107,27 @@ public class ChangeRegionTest extends TestCase {
 		r.adjustTo(new Hunk(15, 3, 2));
 		RangeUtil.assertEqualRanges(before, r.getAdjustedRanges());
 		RangeUtil.assertEqualRange((ILineRange) before.get(0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		before= RangeUtil.deepClone(r.getAdjustedRanges());
 		r.adjustTo(new Hunk(15, -3, 2));
 		RangeUtil.assertEqualRanges(before, r.getAdjustedRanges());
 		RangeUtil.assertEqualRange((ILineRange) before.get(0), r.getAdjustedCoverage());
 	}
-	
+
 	public void testHunkBefore() throws Exception {
 		ChangeRegion r;
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		r.adjustTo(new Hunk(5, 3, 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(15, 3), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(15, 3), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		r.adjustTo(new Hunk(5, 3, 0));
 		RangeUtil.assertEqualSingleRange(new LineRange(15, 3), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(15, 3), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		r.adjustTo(new Hunk(5, -3, 0));
 		RangeUtil.assertEqualSingleRange(new LineRange(9, 3), r.getAdjustedRanges());
@@ -137,36 +137,36 @@ public class ChangeRegionTest extends TestCase {
 		r.adjustTo(new Hunk(5, 3, 3));
 		RangeUtil.assertEqualSingleRange(new LineRange(15, 3), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(15, 3), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		r.adjustTo(new Hunk(5, -3, 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(9, 3), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(9, 3), r.getAdjustedCoverage());
 	}
-	
+
 	public void testHunkRightBefore() throws Exception {
 		ChangeRegion r;
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		r.adjustTo(new Hunk(10, 0 , 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(12, 3), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 3), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		r.adjustTo(new Hunk(10, 2 , 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(14, 3), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(14, 3), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		r.adjustTo(new Hunk(9, -3, 0));
 		RangeUtil.assertEqualSingleRange(new LineRange(9, 3), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(9, 3), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		r.adjustTo(new Hunk(9, -1, 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(11, 3), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(11, 3), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 3));
 		r.adjustTo(new Hunk(9, 3, 3));
 		RangeUtil.assertEqualSingleRange(new LineRange(15, 3), r.getAdjustedRanges());
@@ -177,216 +177,216 @@ public class ChangeRegionTest extends TestCase {
 		RangeUtil.assertEqualSingleRange(new LineRange(15, 3), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(15, 3), r.getAdjustedCoverage());
 	}
-	
+
 	public void testHunkAtStart() throws Exception {
 		ChangeRegion r;
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(12, 0 , 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(14, 5), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(14, 5), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(12, -2, 0));
 		RangeUtil.assertEqualSingleRange(new LineRange(12, 5), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 5), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(12, -2, 1));
 		RangeUtil.assertEqualSingleRange(new LineRange(13, 4), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(13, 4), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(12, 3, 0));
 		RangeUtil.assertEqualSingleRange(new LineRange(15, 7), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(15, 7), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(12, 3, 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(17, 5), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(17, 5), r.getAdjustedCoverage());
 	}
-	
+
 	public void testHunkAtEnd() throws Exception {
 		ChangeRegion r;
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(17, 0, 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(12, 5), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 5), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(17, 2, 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(12, 5), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 5), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(15, -2, 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(12, 3), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 3), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(17, -2, 0));
 		RangeUtil.assertEqualSingleRange(new LineRange(12, 5), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 5), r.getAdjustedCoverage());
 	}
-	
+
 	public void testHunkOverStart() throws Exception {
 		ChangeRegion r;
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(11, 0 , 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(13, 6), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(13, 6), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(11, 2, 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(15, 6), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(15, 6), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(11, -2, 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(13, 4), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(13, 4), r.getAdjustedCoverage());
 	}
-	
+
 	public void testHunkOverEnd() throws Exception {
 		ChangeRegion r;
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(18, 0 , 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(12, 6), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 6), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(18, -2, 0));
 		RangeUtil.assertEqualSingleRange(new LineRange(12, 6), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 6), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(18, -2, 2));
 		RangeUtil.assertEqualSingleRange(new LineRange(12, 6), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 6), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(17, -2, 1));
 		RangeUtil.assertEqualSingleRange(new LineRange(12, 5), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 5), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(17, -2, 3));
 		RangeUtil.assertEqualSingleRange(new LineRange(12, 5), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 5), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(17, 2, 3));
 		RangeUtil.assertEqualSingleRange(new LineRange(12, 5), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 5), r.getAdjustedCoverage());
 	}
-	
+
 	public void testHunkCovering() throws Exception {
 		ChangeRegion r;
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(12, 0 , 7));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(11, 0 , 8));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(11, 0 , 9));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(12, 0 , 9));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(12, -7, 0));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(12, -8, 0));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(11, -8, 0));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(11, -9, 0));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(8, -9, 6));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(8, -4, 8));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(8, -3, 9));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(8, -12, 5));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(8, -12, 20));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(8, 12, 20));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(8, -3, 8));
 		assertTrue(r.getAdjustedRanges().isEmpty());
 		RangeUtil.assertEqualRange(new LineRange(12, 0), r.getAdjustedCoverage());
 	}
-	
+
 	public void testHunkInBetween() throws Exception {
 		// TODO require merging of adjacent ranges?
 		ChangeRegion r;
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(15, -2, 0));
 		RangeUtil.assertEqualRanges(new LineRange(12, 3), new LineRange(15, 2), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 5), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(15, 2, 0));
 		RangeUtil.assertEqualRanges(new LineRange(12, 3), new LineRange(17, 4), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 9), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(15, 0, 2));
 		RangeUtil.assertEqualRanges(new LineRange(12, 3), new LineRange(17, 2), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 7), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(15, -1, 2));
 		RangeUtil.assertEqualRanges(new LineRange(12, 3), new LineRange(17, 1), r.getAdjustedRanges());
 		RangeUtil.assertEqualRange(new LineRange(12, 6), r.getAdjustedCoverage());
-		
+
 		r= new ChangeRegion(fRevision, new LineRange(12, 7));
 		r.adjustTo(new Hunk(15, 2, 2));
 		RangeUtil.assertEqualRanges(new LineRange(12, 3), new LineRange(19, 2), r.getAdjustedRanges());
diff --git a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/HunkComputerTest.java b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/HunkComputerTest.java
index 408902c41f4..f538c36738f 100644
--- a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/HunkComputerTest.java
+++ b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/HunkComputerTest.java
@@ -14,13 +14,13 @@ import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
+import org.eclipse.jface.internal.text.revisions.Hunk;
+import org.eclipse.jface.internal.text.revisions.HunkComputer;
+
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.source.ILineDiffInfo;
 import org.eclipse.jface.text.source.ILineDiffer;
 
-import org.eclipse.jface.internal.text.revisions.Hunk;
-import org.eclipse.jface.internal.text.revisions.HunkComputer;
-
 /**
  * Tests {@link HunkComputer}.
  *
@@ -28,13 +28,13 @@ import org.eclipse.jface.internal.text.revisions.HunkComputer;
  */
 public class HunkComputerTest extends TestCase {
 	public static Test suite() {
-		return new TestSuite(HunkComputerTest.class); 
+		return new TestSuite(HunkComputerTest.class);
 	}
 
 	private static final int A= ILineDiffInfo.ADDED;
 	private static final int C= ILineDiffInfo.CHANGED;
 	private static final int U= ILineDiffInfo.UNCHANGED;
-	
+
 	private int[] fDiffInformation;
 	private ILineDiffer fDiffer= new ILineDiffer() {
 
@@ -83,128 +83,128 @@ public class HunkComputerTest extends TestCase {
 	};
 	private int[] fRemovedBelow;
 
-	
+
 	public void testNoDiff() throws Exception {
 		int[] diffInfo= new int[] {U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, };
 		int[] expected= {};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testShiftOne() throws Exception {
 		int[] diffInfo= new int[] {C, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, };
 		int[] expected= {0, 0, 1};
-		
+
 		assertHunks(diffInfo, expected);
 	}
 
 	public void testRemoveFirstLine() throws Exception {
 		int[] diffInfo= new int[] {U, 1, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, };
 		int[] expected= {0, -1, 0};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testRemoveSecondLine() throws Exception {
 		int[] diffInfo= new int[] {U, 0, U, 1, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, };
 		int[] expected= {1, -1, 0};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testAddFirstLine() throws Exception {
 		int[] diffInfo= new int[] {A, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, };
 		int[] expected= {0, 1, 0};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testAddSecondLine() throws Exception {
 		int[] diffInfo= new int[] {U, 0, A, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, };
 		int[] expected= {1, 1, 0};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testAddThirdLine() throws Exception {
 		int[] diffInfo= new int[] {U, 0, U, 0, A, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, };
 		int[] expected= {2, 1, 0};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testRemoveFirstRegion() throws Exception {
 		int[] diffInfo= new int[] {U, 2, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, };
 		int[] expected= {0, -2, 0};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testReplaceFirstRegion() throws Exception {
 		int[] diffInfo= new int[] {C, 0, C, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, };
 		int[] expected= {0, 0, 2};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testRemoveOverlappingRegion() throws Exception {
 		int[] diffInfo= new int[] {U, 0, U, 2, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, };
 		int[] expected= {1, -2, 0};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testReplaceOverlappingRegion() throws Exception {
 		int[] diffInfo= new int[] {U, 0, C, 0, C, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, };
 		int[] expected= {1, 0, 2};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testRemoveInnerLines() throws Exception {
 		int[] diffInfo= new int[] {U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 2, };
 		int[] expected= {8, -2, 0};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testReplaceInnerLines() throws Exception {
 		int[] diffInfo= new int[] {U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, C, 0, C, 0, U, 0, };
 		int[] expected= {8, 0, 2};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testAddInnerLines() throws Exception {
 		int[] diffInfo= new int[] {U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, A, 0, A, 0, U, 0, U, 0, U, 0, };
 		int[] expected= {8, +2, 0};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testRemoveLastLine() throws Exception {
 		int[] diffInfo= new int[] {U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0};
 		fRemovedBelow= new int[10];
 		fRemovedBelow[9]= 1;
 		int[] expected= {10, -1, 0};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testReplaceLastLine() throws Exception {
 		int[] diffInfo= new int[] {U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, C, 0, };
 		int[] expected= {10, 0, 1};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	public void testAddLastLine() throws Exception {
 		int[] diffInfo= new int[] {U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, U, 0, A, 0, };
 		int[] expected= {12, 1, 0};
-		
+
 		assertHunks(diffInfo, expected);
 	}
-	
+
 	private void assertHunks(int[] diffInfo, int[] expected) {
 		fDiffInformation= diffInfo;
 		assertEquals(0, diffInfo.length % 2);
diff --git a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/RangeTest.java b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/RangeTest.java
index 9819e99c5e4..aba3b9d3f6e 100644
--- a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/RangeTest.java
+++ b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/RangeTest.java
@@ -14,14 +14,14 @@ import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
-import org.eclipse.jface.text.source.LineRange;
-
 import org.eclipse.jface.internal.text.revisions.LineIndexOutOfBoundsException;
 import org.eclipse.jface.internal.text.revisions.Range;
 
+import org.eclipse.jface.text.source.LineRange;
+
 public class RangeTest extends TestCase {
 	public static Test suite() {
-		return new TestSuite(RangeTest.class); 
+		return new TestSuite(RangeTest.class);
 	}
 
 	public void testLegalOperations() {
@@ -29,22 +29,22 @@ public class RangeTest extends TestCase {
 		assertEquals(0, r.start());
 		assertEquals(1, r.length());
 		assertConsistency(r);
-		
+
 		r= Range.createAbsolute(5, 6);
 		assertEquals(5, r.start());
 		assertEquals(1, r.length());
 		assertConsistency(r);
-		
+
 		r= Range.copy(new LineRange(5, 1));
 		assertEquals(5, r.start());
 		assertEquals(1, r.length());
 		assertConsistency(r);
-		
+
 		r= Range.createRelative(5, 1);
 		assertEquals(5, r.start());
 		assertEquals(1, r.length());
 		assertConsistency(r);
-		
+
 		r.moveBy(10);
 		assertEquals(15, r.start());
 		assertEquals(1, r.length());
@@ -54,149 +54,149 @@ public class RangeTest extends TestCase {
 		assertEquals(7, r.start());
 		assertEquals(1, r.length());
 		assertConsistency(r);
-		
+
 		r.moveTo(12);
 		assertEquals(12, r.start());
 		assertEquals(1, r.length());
 		assertConsistency(r);
-		
+
 		r.resizeBy(4);
 		assertEquals(12, r.start());
 		assertEquals(5, r.length());
 		assertConsistency(r);
-		
+
 		r.resizeAndMoveBy(3);
 		assertEquals(15, r.start());
 		assertEquals(2, r.length());
 		assertConsistency(r);
-		
+
 		r.resizeAndMoveBy(-3);
 		assertEquals(12, r.start());
 		assertEquals(5, r.length());
 		assertConsistency(r);
-		
+
 		r.setLength(3);
 		assertEquals(12, r.start());
 		assertEquals(3, r.length());
 		assertConsistency(r);
-		
+
 		r.resizeBy(13);
 		assertEquals(12, r.start());
 		assertEquals(16, r.length());
 		assertConsistency(r);
-		
+
 		r.resizeBy(-4);
 		assertEquals(12, r.start());
 		assertEquals(12, r.length());
 		assertConsistency(r);
-		
+
 		r.setEnd(18);
 		assertEquals(12, r.start());
 		assertEquals(6, r.length());
 		assertConsistency(r);
-		
+
 		r.moveEndTo(13);
 		assertEquals(7, r.start());
 		assertEquals(6, r.length());
 		assertConsistency(r);
-		
+
 		r.setLengthAndMove(3);
 		assertEquals(10, r.start());
 		assertEquals(3, r.length());
 		assertConsistency(r);
-		
+
 		r.setStart(7);
 		assertEquals(7, r.start());
 		assertEquals(6, r.length());
 		assertConsistency(r);
 	}
-	
+
 	public void testSplit() throws Exception {
 		Range r= Range.createRelative(12, 18);
 		Range second= r.split(8);
 		assertEquals(12, r.start());
 		assertEquals(8, r.length());
 		assertConsistency(r);
-		
+
 		assertEquals(20, second.start());
 		assertEquals(10, second.length());
 		assertConsistency(second);
 	}
-	
+
 	public void testIllegalOperations() throws Exception {
-		
+
 		try {
 			Range.copy(null);
 			fail();
 		} catch (NullPointerException e) {
 		}
-		
+
 		try {
 			Range.createRelative(0, 0);
 			fail();
 		} catch (LineIndexOutOfBoundsException e) {
 		}
-		
+
 		try {
 			Range.createRelative(0, -1);
 			fail();
 		} catch (LineIndexOutOfBoundsException e) {
 		}
-		
+
 		try {
 			Range.createRelative(-1, 0);
 			fail();
 		} catch (LineIndexOutOfBoundsException e) {
 		}
-		
+
 		try {
 			Range.createRelative(-1, -1);
 			fail();
 		} catch (LineIndexOutOfBoundsException e) {
 		}
-		
+
 		try {
 			Range.createAbsolute(0, 0);
 			fail();
 		} catch (LineIndexOutOfBoundsException e) {
 		}
-		
+
 		try {
 			Range.createAbsolute(0, -1);
 			fail();
 		} catch (LineIndexOutOfBoundsException e) {
 		}
-		
+
 		try {
 			Range.createAbsolute(-1, 0);
 			fail();
 		} catch (LineIndexOutOfBoundsException e) {
 		}
-		
+
 		try {
 			Range.createAbsolute(-1, 12);
 			fail();
 		} catch (LineIndexOutOfBoundsException e) {
 		}
-		
+
 		try {
 			Range.createAbsolute(10, 10);
 			fail();
 		} catch (LineIndexOutOfBoundsException e) {
 		}
-		
+
 		try {
 			Range.createAbsolute(12, 10);
 			fail();
 		} catch (LineIndexOutOfBoundsException e) {
 		}
-		
+
 		try {
 			Range.createAbsolute(12, -3);
 			fail();
 		} catch (LineIndexOutOfBoundsException e) {
 		}
-		
+
 		Range r= Range.createRelative(5, 10);
 
 		try {
@@ -218,7 +218,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.resizeBy(-11);
 			fail();
@@ -236,7 +236,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.resizeAndMoveBy(10);
 			fail();
@@ -245,7 +245,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.resizeAndMoveBy(11);
 			fail();
@@ -254,7 +254,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.resizeAndMoveBy(20);
 			fail();
@@ -263,7 +263,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.setLength(0);
 			fail();
@@ -272,7 +272,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.setLength(-1);
 			fail();
@@ -281,7 +281,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.moveTo(-1);
 			fail();
@@ -290,7 +290,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.setEnd(5);
 			fail();
@@ -299,7 +299,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.setEnd(3);
 			fail();
@@ -308,7 +308,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.setEnd(-5);
 			fail();
@@ -317,7 +317,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.setStart(18);
 			fail();
@@ -326,7 +326,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.moveEndTo(9);
 			fail();
@@ -335,7 +335,7 @@ public class RangeTest extends TestCase {
 			assertEquals(10, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.setLengthAndMove(16);
 			fail();
@@ -345,10 +345,10 @@ public class RangeTest extends TestCase {
 			assertConsistency(r);
 		}
 	}
-	
+
 	public void testIllegalSplit() throws Exception {
 		Range r= Range.createRelative(12, 18);
-		
+
 		try {
 			r.split(-1);
 		} catch (LineIndexOutOfBoundsException e) {
@@ -356,7 +356,7 @@ public class RangeTest extends TestCase {
 			assertEquals(18, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.split(0);
 		} catch (LineIndexOutOfBoundsException e) {
@@ -364,7 +364,7 @@ public class RangeTest extends TestCase {
 			assertEquals(18, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.split(18);
 		} catch (LineIndexOutOfBoundsException e) {
@@ -372,7 +372,7 @@ public class RangeTest extends TestCase {
 			assertEquals(18, r.length());
 			assertConsistency(r);
 		}
-		
+
 		try {
 			r.split(20);
 		} catch (LineIndexOutOfBoundsException e) {
@@ -381,7 +381,7 @@ public class RangeTest extends TestCase {
 			assertConsistency(r);
 		}
 	}
-	
+
 	private static void assertConsistency(Range r) {
 		assertEquals(r, r);
 		assertTrue(r.equalRange(Range.copy(r)));
diff --git a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/RangeUtil.java b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/RangeUtil.java
index f04f7f7c2b6..a232d63d265 100644
--- a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/RangeUtil.java
+++ b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/revisions/RangeUtil.java
@@ -16,10 +16,10 @@ import java.util.List;
 
 import junit.framework.Assert;
 
-import org.eclipse.jface.text.source.ILineRange;
-
 import org.eclipse.jface.internal.text.revisions.Range;
 
+import org.eclipse.jface.text.source.ILineRange;
+
 class RangeUtil extends Assert {
 	private RangeUtil() {}
 
diff --git a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/rulers/DAGTest.java b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/rulers/DAGTest.java
index bf140cfaf4e..34200e55441 100644
--- a/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/rulers/DAGTest.java
+++ b/org.eclipse.ui.workbench.texteditor.tests/src/org/eclipse/ui/workbench/texteditor/tests/rulers/DAGTest.java
@@ -34,15 +34,15 @@ public class DAGTest extends TestCase {
 	private static final Set CD= new LinkedHashSet(Arrays.asList(new Object[] { C, D }));
 	private static final Set ACD= new LinkedHashSet(Arrays.asList(new Object[] { A, C, D }));
 	private static final Set BD= new LinkedHashSet(Arrays.asList(new Object[] { B, D }));
-	
+
 	private DAG fDag= new DAG();
-	
+
 	public void testEmpty() throws Exception {
 		assertTrue(fDag.getChildren(new Object()).isEmpty());
 		assertTrue(fDag.getSources().isEmpty());
 		assertTrue(fDag.getSinks().isEmpty());
 	}
-	
+
 	public void testIllegal() throws Exception {
 		assertFalse(fDag.addEdge(A, A));
 		try {
@@ -66,7 +66,7 @@ public class DAGTest extends TestCase {
 		} catch (RuntimeException x) {
 		}
 	}
-	
+
 	public void testDag() throws Exception {
 		assertTrue(fDag.addEdge(A, B));
 		assertEquals(AS, fDag.getSources());
@@ -78,7 +78,7 @@ public class DAGTest extends TestCase {
 		assertTrue(fDag.getChildren(B).isEmpty());
 		assertTrue(fDag.getChildren(C).isEmpty());
 		assertTrue(fDag.getChildren(D).isEmpty());
-		
+
 		assertTrue(fDag.addEdge(B, C));
 		assertEquals(AS, fDag.getSources());
 		assertEquals(CS, fDag.getSinks());
@@ -86,7 +86,7 @@ public class DAGTest extends TestCase {
 		assertEquals(CS, fDag.getChildren(B));
 		assertTrue(fDag.getChildren(C).isEmpty());
 		assertTrue(fDag.getChildren(D).isEmpty());
-		
+
 		fDag.addVertex(C);
 		assertEquals(AS, fDag.getSources());
 		assertEquals(CS, fDag.getSinks());
@@ -94,7 +94,7 @@ public class DAGTest extends TestCase {
 		assertEquals(CS, fDag.getChildren(B));
 		assertTrue(fDag.getChildren(C).isEmpty());
 		assertTrue(fDag.getChildren(D).isEmpty());
-		
+
 		fDag.addVertex(D);
 		assertEquals(AD, fDag.getSources());
 		assertEquals(CD, fDag.getSinks());
@@ -102,7 +102,7 @@ public class DAGTest extends TestCase {
 		assertEquals(CS, fDag.getChildren(B));
 		assertTrue(fDag.getChildren(C).isEmpty());
 		assertTrue(fDag.getChildren(D).isEmpty());
-		
+
 		fDag.removeVertex(A);
 		assertEquals(BD, fDag.getSources());
 		assertEquals(CD, fDag.getSinks());
@@ -110,7 +110,7 @@ public class DAGTest extends TestCase {
 		assertEquals(CS, fDag.getChildren(B));
 		assertTrue(fDag.getChildren(C).isEmpty());
 		assertTrue(fDag.getChildren(D).isEmpty());
-		
+
 		assertTrue(fDag.addEdge(A, B));
 		assertTrue(fDag.addEdge(D, B));
 		assertEquals(AD, fDag.getSources());
@@ -119,7 +119,7 @@ public class DAGTest extends TestCase {
 		assertEquals(CS, fDag.getChildren(B));
 		assertTrue(fDag.getChildren(C).isEmpty());
 		assertEquals(BS, fDag.getChildren(D));
-		
+
 		fDag.removeVertex(B);
 		assertEquals(ACD, fDag.getSources());
 		assertEquals(ACD, fDag.getSinks());