Bug 382427 - Mechanism to inject line compare strategies into merge and

structure viewers

Change-Id: Iec597bd9582933b90f67de94547b4ccdaef9a319

6 files changed, 514 insertions, 16 deletions

diff --git a/tests/org.eclipse.compare.tests/META-INF/MANIFEST.MF b/tests/org.eclipse.compare.tests/META-INF/MANIFEST.MF
index 15b8c032a..e7a39c5a9 100644
--- a/tests/org.eclipse.compare.tests/META-INF/MANIFEST.MF
+++ b/tests/org.eclipse.compare.tests/META-INF/MANIFEST.MF
@@ -2,7 +2,7 @@ Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.compare.tests;singleton:=true
-Bundle-Version: 3.5.400.qualifier
+Bundle-Version: 3.6.0.qualifier
 Bundle-ClassPath: comparetests.jar
 Require-Bundle: org.junit,
  org.eclipse.compare,
diff --git a/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/AllTests.java b/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/AllTests.java
index a47c61fc2..061de77e5 100644
--- a/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/AllTests.java
+++ b/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/AllTests.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2011 IBM Corporation and others.
+ * Copyright (c) 2000, 2013 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
@@ -36,6 +36,7 @@ public class AllTests {
 		suite.addTestSuite(PatchUITest.class);
 		suite.addTestSuite(RangeDifferencerThreeWayDiffTest.class);
 		suite.addTestSuite(CompareUIPluginTest.class);
+		suite.addTestSuite(StructureCreatorTest.class);
 		// $JUnit-END$
 		return suite;
 	}
diff --git a/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/DocLineComparatorTest.java b/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/DocLineComparatorTest.java
index cf963c76b..5c8b7c6f7 100644
--- a/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/DocLineComparatorTest.java
+++ b/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/DocLineComparatorTest.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2009 IBM Corporation and others.
+ * Copyright (c) 2000, 2013 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
@@ -10,13 +10,17 @@
  *******************************************************************************/
 package org.eclipse.compare.tests;
 
+import java.util.HashMap;
+
 import junit.framework.Assert;
 import junit.framework.TestCase;
 
+import org.eclipse.compare.ICompareFilter;
 import org.eclipse.compare.internal.DocLineComparator;
 import org.eclipse.compare.rangedifferencer.IRangeComparator;
 import org.eclipse.jface.text.Document;
 import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.IRegion;
 import org.eclipse.jface.text.Region;
 
 public class DocLineComparatorTest extends TestCase {
@@ -59,6 +63,212 @@ public class DocLineComparatorTest extends TestCase {
 		Assert.assertTrue(comp1.rangesEqual(0, comp2, 0));
 	}
 
+	public void testOneCompareFilter() {
+		IDocument doc1 = new Document();
+		doc1.set("if (s.strip))"); //$NON-NLS-1$
+
+		IDocument doc2 = new Document();
+		doc2.set("IF (S.stRIp))"); //$NON-NLS-1$
+
+		IDocument doc3 = new Document();
+		doc3.set("IF (S.stRIp))   "); //$NON-NLS-1$
+
+		ICompareFilter filter = new ICompareFilter() {
+
+			public void setInput(Object input, Object ancestor, Object left,
+					Object right) {
+				// EMPTY
+			}
+
+			public IRegion[] getFilteredRegions(HashMap lineComparison) {
+				return new IRegion[] { new Region(0, 2), new Region(4, 1),
+						new Region(8, 2) };
+			}
+
+			public boolean isEnabledInitially() {
+				return false;
+			}
+
+			public boolean canCacheFilteredRegions() {
+				return false;
+			}
+		};
+
+		IRangeComparator comp1 = new DocLineComparator(doc1, null, false,
+				new ICompareFilter[] { filter }, 'L');
+		IRangeComparator comp2 = new DocLineComparator(doc2, null, false,
+				new ICompareFilter[] { filter }, 'R');
+		Assert.assertTrue(comp1.rangesEqual(0, comp2, 0));
+
+		IRangeComparator comp3 = new DocLineComparator(doc1, null, true,
+				new ICompareFilter[] { filter }, 'L');
+		IRangeComparator comp4 = new DocLineComparator(doc3, null, true,
+				new ICompareFilter[] { filter }, 'R');
+		Assert.assertTrue(comp3.rangesEqual(0, comp4, 0));
+
+		IRangeComparator comp5 = new DocLineComparator(doc1, null, false,
+				new ICompareFilter[] { filter }, 'L');
+		IRangeComparator comp6 = new DocLineComparator(doc3, null, false,
+				new ICompareFilter[] { filter }, 'R');
+		Assert.assertFalse(comp5.rangesEqual(0, comp6, 0));
+	}
+
+	public void testMultipleCompareFilters() {
+		IDocument doc1 = new Document();
+		doc1.set("if (s.strip))"); //$NON-NLS-1$
+
+		IDocument doc2 = new Document();
+		doc2.set("IF (S.stRIp))"); //$NON-NLS-1$
+
+		ICompareFilter filter1 = new ICompareFilter() {
+
+			public void setInput(Object input, Object ancestor, Object left,
+					Object right) {
+				// EMPTY
+			}
+
+			public IRegion[] getFilteredRegions(HashMap lineComparison) {
+				return new IRegion[] { new Region(0, 2) };
+			}
+
+			public boolean isEnabledInitially() {
+				return false;
+			}
+
+			public boolean canCacheFilteredRegions() {
+				return false;
+			}
+		};
+
+		ICompareFilter filter2 = new ICompareFilter() {
+
+			public void setInput(Object input, Object ancestor, Object left,
+					Object right) {
+				// EMPTY
+			}
+
+			public IRegion[] getFilteredRegions(HashMap lineComparison) {
+				return new IRegion[] { new Region(4, 1) };
+			}
+
+			public boolean isEnabledInitially() {
+				return false;
+			}
+
+			public boolean canCacheFilteredRegions() {
+				return false;
+			}
+		};
+
+		ICompareFilter filter3 = new ICompareFilter() {
+
+			public void setInput(Object input, Object ancestor, Object left,
+					Object right) {
+				// EMPTY
+			}
+
+			public IRegion[] getFilteredRegions(HashMap lineComparison) {
+				return new IRegion[] { new Region(8, 2) };
+			}
+
+			public boolean isEnabledInitially() {
+				return false;
+			}
+
+			public boolean canCacheFilteredRegions() {
+				return false;
+			}
+		};
+
+		IRangeComparator comp1 = new DocLineComparator(doc1, null, false,
+				new ICompareFilter[] { filter1, filter2, filter3 }, 'L');
+		IRangeComparator comp2 = new DocLineComparator(doc2, null, false,
+				new ICompareFilter[] { filter1, filter2, filter3 }, 'R');
+		Assert.assertTrue(comp1.rangesEqual(0, comp2, 0));
+
+		IRangeComparator comp3 = new DocLineComparator(doc1, null, false,
+				new ICompareFilter[] { filter2, filter3 }, 'L');
+		IRangeComparator comp4 = new DocLineComparator(doc2, null, false,
+				new ICompareFilter[] { filter2, filter3 }, 'R');
+		Assert.assertFalse(comp3.rangesEqual(0, comp4, 0));
+	}
+	
+	public void testWhitespace() {
+		IDocument[] docs = new IDocument[6];
+		docs[0] = new Document();
+		docs[1] = new Document();
+		docs[2] = new Document();
+		docs[3] = new Document();
+		docs[4] = new Document();
+		docs[5] = new Document();
+		
+		docs[0].set("if (s.strip))\r\n");//$NON-NLS-1$
+		docs[1].set("if (s.strip))\n");  //$NON-NLS-1$
+		docs[2].set("if (s .strip))\n"); //$NON-NLS-1$
+		docs[3].set("if (s.str ip))\r"); //$NON-NLS-1$
+		docs[4].set("if (s.strip))");    //$NON-NLS-1$
+		docs[5].set("if (s.stri p))");   //$NON-NLS-1$
+		
+		ICompareFilter[][] filters = new ICompareFilter[3][];
+		filters[0] = null;
+		filters[1] = new ICompareFilter[]{
+				new ICompareFilter() {
+
+					public void setInput(Object input, Object ancestor, Object left,
+							Object right) {
+						// EMPTY
+					}
+		
+					public IRegion[] getFilteredRegions(HashMap lineComparison) {
+						return new IRegion[] { new Region(0, 2) };
+					}
+		
+					public boolean isEnabledInitially() {
+						return false;
+					}
+		
+					public boolean canCacheFilteredRegions() {
+						return true; // cache-able
+					}
+				}
+		};
+		
+		filters[2] = new ICompareFilter[]{
+				new ICompareFilter() {
+
+					public void setInput(Object input, Object ancestor, Object left,
+							Object right) {
+						// EMPTY
+					}
+		
+					public IRegion[] getFilteredRegions(HashMap lineComparison) {
+						return new IRegion[] { new Region(0, 2) };
+					}
+		
+					public boolean isEnabledInitially() {
+						return false;
+					}
+		
+					public boolean canCacheFilteredRegions() {
+						return false; // not cache-able
+					}
+				}
+		};
+
+		IRangeComparator l, r;
+		for (int i=0;i<docs.length;i++)
+			for (int j=i+1;j<docs.length;j++)
+				for (int k=0;k<filters.length;k++) {
+					l = new DocLineComparator(docs[i], null, false, filters[k], 'L');
+					r = new DocLineComparator(docs[j], null, false, filters[k], 'R');
+					Assert.assertFalse(l.rangesEqual(0, r, 0));
+					
+					l = new DocLineComparator(docs[i], null, true, filters[k], 'L');
+					r = new DocLineComparator(docs[j], null, true, filters[k], 'R');
+					Assert.assertTrue(l.rangesEqual(0, r, 0));
+			}
+	}
+
 	public void testEmpty() {
 		IDocument doc1= new Document();
 		doc1.set(""); //$NON-NLS-1$
diff --git a/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/FilterTest.java b/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/FilterTest.java
index 2e1e48bdc..29016b197 100644
--- a/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/FilterTest.java
+++ b/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/FilterTest.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2006 IBM Corporation and others.
+ * Copyright (c) 2000, 2013 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
@@ -10,42 +10,42 @@
  *******************************************************************************/
 package org.eclipse.compare.tests;
 
-import org.eclipse.compare.internal.CompareFilter;
+import org.eclipse.compare.internal.CompareResourceFilter;
 
 import junit.framework.*;
 import junit.framework.TestCase;
 
 public class FilterTest extends TestCase {
 	
-	CompareFilter fFilter;
+	CompareResourceFilter fFilter;
 	
 	public FilterTest(String name) {
 		super(name);
 	}
 		
 	public void testFilterFile() {
-		CompareFilter f= new CompareFilter();
+		CompareResourceFilter f= new CompareResourceFilter();
 		f.setFilters("*.class"); //$NON-NLS-1$
 		Assert.assertTrue("file foo.class should be filtered", f.filter("foo.class", false, false)); //$NON-NLS-1$ //$NON-NLS-2$
 		Assert.assertFalse("file foo.java shouldn't be filtered", f.filter("foo.java", false, false)); //$NON-NLS-1$ //$NON-NLS-2$
 	}
 	
 	public void testFilterDotFile() {
-		CompareFilter f= new CompareFilter();
+		CompareResourceFilter f= new CompareResourceFilter();
 		f.setFilters(".cvsignore"); //$NON-NLS-1$
 		Assert.assertTrue("file .cvsignore should be filtered", f.filter(".cvsignore", false, false)); //$NON-NLS-1$ //$NON-NLS-2$
 		Assert.assertFalse("file foo.cvsignore shouldn't be filtered", f.filter("foo.cvsignore", false, false)); //$NON-NLS-1$ //$NON-NLS-2$
 	}
 	
 	public void testFilterFolder() {
-		CompareFilter f= new CompareFilter();
+		CompareResourceFilter f= new CompareResourceFilter();
 		f.setFilters("bin/"); //$NON-NLS-1$
 		Assert.assertTrue("folder bin should be filtered", f.filter("bin", true, false)); //$NON-NLS-1$ //$NON-NLS-2$
 		Assert.assertFalse("file bin shouldn't be filtered", f.filter("bin", false, false)); //$NON-NLS-1$ //$NON-NLS-2$
 	}
 	
 	public void testMultiFilter() {
-		CompareFilter f= new CompareFilter();
+		CompareResourceFilter f= new CompareResourceFilter();
 		f.setFilters("*.class, .cvsignore, bin/, src/"); //$NON-NLS-1$
 		Assert.assertTrue("file foo.class should be filtered", f.filter("foo.class", false, false)); //$NON-NLS-1$ //$NON-NLS-2$
 		Assert.assertFalse("file foo.java shouldn't be filtered", f.filter("foo.java", false, false)); //$NON-NLS-1$ //$NON-NLS-2$
diff --git a/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/StructureCreatorTest.java b/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/StructureCreatorTest.java
new file mode 100644
index 000000000..27076c691
--- /dev/null
+++ b/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/StructureCreatorTest.java
@@ -0,0 +1,181 @@
+/*******************************************************************************
+ * Copyright (c) 2013 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.compare.tests;
+
+import java.util.HashMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.eclipse.compare.ICompareFilter;
+import org.eclipse.compare.ISharedDocumentAdapter;
+import org.eclipse.compare.structuremergeviewer.DocumentRangeNode;
+import org.eclipse.compare.structuremergeviewer.IStructureComparator;
+import org.eclipse.compare.structuremergeviewer.StructureCreator;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.Document;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.IRegion;
+import org.eclipse.jface.text.Region;
+
+public class StructureCreatorTest extends TestCase {
+
+	public StructureCreatorTest() {
+		super();
+	}
+
+	public StructureCreatorTest(String name) {
+		super(name);
+	}
+
+	public void testIgnoreWhitespace() {
+		IDocument[] docs = new IDocument[15];
+		docs[0] = new Document();
+		docs[1] = new Document();
+		docs[2] = new Document();
+		docs[3] = new Document();
+		docs[4] = new Document();
+		docs[5] = new Document();
+		docs[6] = new Document();
+		docs[7] = new Document();
+		docs[8] = new Document();
+		docs[9] = new Document();
+		docs[10] = new Document();
+		docs[11] = new Document();
+		docs[12] = new Document();
+		docs[13] = new Document();
+		docs[14] = new Document();
+
+		docs[0].set("ABCDEF"); //$NON-NLS-1$
+		docs[1].set("ABC DEF"); //$NON-NLS-1$
+		docs[2].set("ABC\r\nDEF"); //$NON-NLS-1$
+		docs[3].set("ABC\r\nDEF  "); //$NON-NLS-1$
+		docs[4].set("\r\nABC\r\nDEF"); //$NON-NLS-1$
+		docs[5].set("   \r\nABC\r\nDEF"); //$NON-NLS-1$
+		docs[6].set("\r\nABC\r\nDEF\r\n"); //$NON-NLS-1$
+		docs[7].set("\r\nA BC\r\nDE F\r\n"); //$NON-NLS-1$
+		docs[8].set("ABC\r\n\r\nDEF"); //$NON-NLS-1$
+		docs[9].set("ABC\nDEF"); //$NON-NLS-1$
+		docs[10].set("ABC\nDEF   "); //$NON-NLS-1$
+		docs[11].set("ABC\nDEF\n"); //$NON-NLS-1$
+		docs[12].set("\nABCDEF"); //$NON-NLS-1$
+		docs[13].set(" \nAB CD EF"); //$NON-NLS-1$
+		docs[14].set("\nABC\nDEF\n"); //$NON-NLS-1$
+
+		ICompareFilter[][] filters = new ICompareFilter[3][];
+		filters[0] = null;
+		filters[1] = new ICompareFilter[] { new ICompareFilter() {
+
+			public void setInput(Object input, Object ancestor, Object left,
+					Object right) {
+				// EMPTY
+			}
+
+			public IRegion[] getFilteredRegions(HashMap lineComparison) {
+				String line = lineComparison.get(ICompareFilter.THIS_LINE)
+						.toString();
+				int index = line.indexOf("A");
+				if (index > -1)
+					return new IRegion[] { new Region(index, 1) };
+				return null;
+			}
+
+			public boolean isEnabledInitially() {
+				return false;
+			}
+
+			public boolean canCacheFilteredRegions() {
+				return true; // cache-able
+			}
+		} };
+
+		filters[2] = new ICompareFilter[] { new ICompareFilter() {
+
+			public void setInput(Object input, Object ancestor, Object left,
+					Object right) {
+				// EMPTY
+			}
+
+			public IRegion[] getFilteredRegions(HashMap lineComparison) {
+				String line = lineComparison.get(ICompareFilter.THIS_LINE)
+						.toString();
+				int index = line.indexOf("E");
+				if (index > -1)
+					return new IRegion[] { new Region(index, 1) };
+				return null;
+			}
+
+			public boolean isEnabledInitially() {
+				return false;
+			}
+
+			public boolean canCacheFilteredRegions() {
+				return false; // not cache-able
+			}
+		} };
+
+		StructureCreator creator = new StructureCreator() {
+			private Pattern whitespace = Pattern.compile("\\s+");
+			private Matcher matcher = null;
+
+			public String getName() {
+				return "NAME";
+			}
+
+			public String getContents(Object node, boolean ignoreWhitespace) {
+				DocumentRangeNode drn = (DocumentRangeNode) node;
+				String retval = null;
+				try {
+					retval = drn.getDocument().get(drn.getRange().getOffset(),
+							drn.getRange().getLength());
+					if (ignoreWhitespace) {
+						if (matcher == null)
+							matcher = whitespace.matcher(retval);
+						else
+							matcher.reset(retval);
+						retval = matcher.replaceAll("");
+					}
+				} catch (BadLocationException ble) {
+					assertNull(ble);
+				}
+				return retval;
+			}
+
+			protected IStructureComparator createStructureComparator(
+					Object element, IDocument document,
+					ISharedDocumentAdapter sharedDocumentAdapter,
+					IProgressMonitor monitor) throws CoreException {
+				return new DocumentRangeNode(1, "ID", document, 0,
+						document.getLength());
+			}
+
+		};
+		DocumentRangeNode l, r;
+		for (int i = 0; i < docs.length; i++)
+			for (int j = i + 1; j < docs.length; j++)
+				for (int k = 0; k < filters.length; k++) {
+
+					l = new DocumentRangeNode(1, "ID", docs[i], 0,
+							docs[i].getLength());
+					r = new DocumentRangeNode(1, "ID", docs[j], 0,
+							docs[j].getLength());
+					creator.contentsEquals(l, 'L', r, 'R', true, filters[k]);
+					Assert.assertFalse(creator.contentsEquals(l, 'L', r, 'R',
+							false, filters[k]));
+					Assert.assertTrue(creator.contentsEquals(l, 'L', r, 'R',
+							true, filters[k]));
+				}
+	}
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/TextMergeViewerTest.java b/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/TextMergeViewerTest.java
index 608e44743..171d4ac68 100644
--- a/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/TextMergeViewerTest.java
+++ b/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/TextMergeViewerTest.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2006 IBM Corporation and others.
+ * Copyright (c) 2006, 2013 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
@@ -10,21 +10,36 @@
  *******************************************************************************/
 package org.eclipse.compare.tests;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
 
 import junit.framework.TestCase;
 
-import org.eclipse.compare.*;
+import org.eclipse.compare.CompareConfiguration;
+import org.eclipse.compare.ICompareFilter;
+import org.eclipse.compare.IEditableContent;
+import org.eclipse.compare.IStreamContentAccessor;
+import org.eclipse.compare.ITypedElement;
 import org.eclipse.compare.contentmergeviewer.TextMergeViewer;
-import org.eclipse.compare.internal.*;
+import org.eclipse.compare.internal.ChangeCompareFilterPropertyAction;
+import org.eclipse.compare.internal.IMergeViewerTestAdapter;
+import org.eclipse.compare.internal.MergeViewerContentProvider;
+import org.eclipse.compare.internal.Utilities;
 import org.eclipse.compare.structuremergeviewer.DiffNode;
 import org.eclipse.compare.structuremergeviewer.Differencer;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.jface.dialogs.Dialog;
 import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.IRegion;
+import org.eclipse.jface.text.Region;
 import org.eclipse.swt.graphics.Image;
-import org.eclipse.swt.widgets.*;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Shell;
 import org.eclipse.ui.PlatformUI;
 
 public class TextMergeViewerTest extends TestCase {
@@ -157,6 +172,11 @@ public class TextMergeViewerTest extends TestCase {
 		public TestMergeViewer(Composite parent) {
 			super(parent, new CompareConfiguration());
 		}
+
+		public TestMergeViewer(Composite parent, CompareConfiguration cc) {
+			super(parent, cc);
+		}
+
 		public void copy(boolean leftToRight) {
 			super.copy(leftToRight);
 		}
@@ -185,11 +205,16 @@ public class TextMergeViewerTest extends TestCase {
 	}
 	
 	private void runInDialog(Object input, Runnable runnable) throws Exception {
+		runInDialog(input, runnable, new CompareConfiguration());
+	}
+
+	private void runInDialog(Object input, Runnable runnable,
+			final CompareConfiguration cc) throws Exception {
 		Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
 		Dialog dialog = new Dialog(shell) {
 			protected Control createDialogArea(Composite parent) {
 				Composite composite = (Composite) super.createDialogArea(parent);
-				viewer = new TestMergeViewer(composite);
+				viewer = new TestMergeViewer(composite, cc);
 				return composite;
 			}
 		};
@@ -354,5 +379,86 @@ public class TextMergeViewerTest extends TestCase {
 		assertEquals(newText, ((EditableTestElement)testNode.getRight()).getContentsAsString());
 	}
 	
+	public void testCompareFilter() throws Exception {
+		DiffNode parentNode = new DiffNode(new ParentTestElement(),
+				new ParentTestElement());
+
+		final String leftString = "HI there";
+		final String rightString = "hi there";
+		final EditableTestElement leftElement = new EditableTestElement(
+				leftString.getBytes());
+		final EditableTestElement rightElement = new EditableTestElement(
+				rightString.getBytes());
+		DiffNode testNode = new DiffNode(parentNode, Differencer.CHANGE, null,
+				leftElement, rightElement);
+		final CompareConfiguration cc = new CompareConfiguration();
+		runInDialog(testNode, new Runnable() {
+			public void run() {
+				Object adapter = viewer
+						.getAdapter(IMergeViewerTestAdapter.class);
+				if (adapter instanceof IMergeViewerTestAdapter) {
+					IMergeViewerTestAdapter ta = (IMergeViewerTestAdapter) adapter;
+					assertEquals(ta.getChangesCount(), 1);
+
+					Map filters = new HashMap();
+					filters.put("filter.id", new ICompareFilter() {
+						public void setInput(Object input, Object ancestor,
+								Object left, Object right) {
+							assertTrue(leftElement == left);
+							assertTrue(rightElement == right);
+						}
+
+						public IRegion[] getFilteredRegions(
+								HashMap lineComparison) {
+							Object thisLine = lineComparison.get(THIS_LINE);
+							Object thisContributor = lineComparison
+									.get(THIS_CONTRIBUTOR);
+							Object otherLine = lineComparison.get(OTHER_LINE);
+							Object otherContributor = lineComparison
+									.get(OTHER_CONTRIBUTOR);
 
+							if (thisContributor.equals(new Character('L'))) {
+								assertEquals(thisLine, leftString);
+								assertEquals(otherContributor, new Character(
+										'R'));
+								assertEquals(otherLine, rightString);
+							} else {
+								assertEquals(thisContributor,
+										new Character('R'));
+								assertEquals(thisLine, rightString);
+								assertEquals(otherContributor, new Character(
+										'L'));
+								assertEquals(otherLine, leftString);
+							}
+
+							if (thisContributor.equals(new Character('L')))
+								return new IRegion[] { new Region(0, 1),
+										new Region(1, 1) };
+
+							return new IRegion[] { new Region(0, 2) };
+						}
+
+						public boolean isEnabledInitially() {
+							return false;
+						}
+
+						public boolean canCacheFilteredRegions() {
+							return true;
+						}
+
+					});
+
+					cc.setProperty(
+							ChangeCompareFilterPropertyAction.COMPARE_FILTERS,
+							filters);
+					assertEquals(ta.getChangesCount(), 0);
+
+					cc.setProperty(
+							ChangeCompareFilterPropertyAction.COMPARE_FILTERS,
+							null);
+					assertEquals(ta.getChangesCount(), 1);
+				}
+			}
+		}, cc);
+	}
 }