ConflictsGroupTest.java

/*******************************************************************************
 * Copyright (c) 2016 Obeo 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:
 *     Obeo - initial API and implementation
 *     Tanja Mayerhofer - bug 501864
 *******************************************************************************/
package org.eclipse.emf.compare.rcp.ui.tests.structuremergeviewer.groups;

import static com.google.common.base.Predicates.and;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.fromSide;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.util.List;

import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.compare.CompareFactory;
import org.eclipse.emf.compare.Comparison;
import org.eclipse.emf.compare.Conflict;
import org.eclipse.emf.compare.ConflictKind;
import org.eclipse.emf.compare.Diff;
import org.eclipse.emf.compare.DifferenceSource;
import org.eclipse.emf.compare.rcp.ui.internal.EMFCompareRCPUIMessages;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.filters.StructureMergeViewerFilter;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.filters.impl.TechnicalitiesFilter;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.impl.BasicDifferenceGroupImpl;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.impl.ThreeWayComparisonGroupProvider;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.impl.ThreeWayComparisonGroupProvider.CompositeConflict;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.impl.ThreeWayComparisonGroupProvider.ConflictsGroupImpl;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.nodes.ConflictNode;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.nodes.DiffNode;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.nodes.MatchNode;
import org.eclipse.emf.compare.rcp.ui.tests.structuremergeviewer.groups.provider.AbstractTestTreeNodeItemProviderAdapter;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.util.ECrossReferenceAdapter;
import org.eclipse.emf.edit.tree.TreeNode;
import org.eclipse.emf.edit.tree.TreePackage;
import org.junit.Test;

import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import com.google.common.eventbus.EventBus;

@SuppressWarnings("restriction")
public class ConflictsGroupTest extends AbstractTestTreeNodeItemProviderAdapter {

	private static final CompareFactory FACTORY = CompareFactory.eINSTANCE;

	private ECrossReferenceAdapter crossReferenceAdapter;

	@Override
	public void before() throws IOException {
		super.before();
		crossReferenceAdapter = new TestECrossReferenceAdapter();
	}

	/**
	 * Tests that multiple conflicts containing overlapping diffs are merged in the SMV. Overlapping diffs can
	 * happen due to the replacement of refining diffs with their refined diffs in the SMV. This test is
	 * related to <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=501864"</a>
	 */
	@Test
	public void testMergingMultipleConflictsWithOverlappingDiffs() {
		// Create diffs
		final Diff diff1 = FACTORY.createDiff();
		final Diff diff1a = FACTORY.createDiff();
		final Diff diff1b = FACTORY.createDiff();
		diff1.getRefinedBy().add(diff1a);
		diff1.getRefinedBy().add(diff1b);

		final Diff diff2 = FACTORY.createDiff();

		final Diff diff3 = FACTORY.createDiff();
		final Diff diff3a = FACTORY.createDiff();
		final Diff diff3b = FACTORY.createDiff();
		diff3.getRefinedBy().add(diff3a);
		diff3.getRefinedBy().add(diff3b);

		final Diff diff4 = FACTORY.createDiff();

		// Create overlapping conflicts
		Conflict conflict1 = FACTORY.createConflict();
		conflict1.getDifferences().add(diff1a);
		conflict1.getDifferences().add(diff2);

		Conflict conflict2 = FACTORY.createConflict();
		conflict2.getDifferences().add(diff3a);
		conflict2.getDifferences().add(diff4);

		Conflict conflict3 = FACTORY.createConflict();
		conflict3.getDifferences().add(diff1b);
		conflict3.getDifferences().add(diff3b);

		// Create comparison
		final Comparison comparison = FACTORY.createComparison();
		comparison.getConflicts().add(conflict1);
		comparison.getConflicts().add(conflict2);
		comparison.getConflicts().add(conflict3);

		// Build conflict nodes
		final ConflictsGroupImpl conflictsGroup = buildConflictGroup(comparison);

		// One conflict node was created
		List<? extends TreeNode> conflictNodes = conflictsGroup.getChildren();
		assertEquals(1, conflictNodes.size());

		// The conflict node groups the three created conflicts
		ConflictNode conflictNode = (ConflictNode)conflictNodes.get(0);
		CompositeConflict compositeConflict = (CompositeConflict)conflictNode.basicGetData();
		assertEquals(3, compositeConflict.getConflicts().size());

		// The composite conflict contains all refined diffs
		EList<Diff> differences = compositeConflict.getDifferences();
		assertEquals(4, differences.size());
		assertTrue(differences.contains(diff1));
		assertTrue(differences.contains(diff2));
		assertTrue(differences.contains(diff3));
		assertTrue(differences.contains(diff4));
	}

	/**
	 * Tests that a composite conflict has the conflict kind {@link ConflictKind#REAL} if it contains at least
	 * one conflict of conflict kind {@link ConflictKind#REAL}. This test is related to <a
	 * href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=501864"</a>
	 */
	@Test
	public void testDerivationOfConflictGroupKindReal() {
		final Conflict realConflict = FACTORY.createConflict();
		realConflict.setKind(ConflictKind.REAL);

		final Conflict pseudoConflict = FACTORY.createConflict();
		pseudoConflict.setKind(ConflictKind.PSEUDO);

		final CompositeConflict realCompositeConflict = new CompositeConflict(realConflict);
		assertEquals(ConflictKind.REAL, realCompositeConflict.getKind());

		final CompositeConflict pseudoCompositeConflict = new CompositeConflict(pseudoConflict);
		assertEquals(ConflictKind.PSEUDO, pseudoCompositeConflict.getKind());

		// The union of one real conflict and one pseudo conflict results in a composite conflict with
		// conflict kind real
		pseudoCompositeConflict.join(realCompositeConflict);
		final CompositeConflict mergedConflictGroup = pseudoCompositeConflict;
		assertEquals(2, mergedConflictGroup.getConflicts().size());
		assertTrue(mergedConflictGroup.getConflicts().contains(realConflict));
		assertTrue(mergedConflictGroup.getConflicts().contains(pseudoConflict));
		assertEquals(ConflictKind.REAL, mergedConflictGroup.getKind());
	}

	/**
	 * Tests that a composite conflict has the conflict kind {@link ConflictKind#PSEUDO} if it contains only
	 * conflicts of conflict kind {@link ConflictKind#PSEUDO}. This test is related to <a
	 * href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=501864"</a>
	 */
	@Test
	public void testDerivationOfConflictGroupKindPseudo() {
		final Conflict pseudoConflict1 = FACTORY.createConflict();
		pseudoConflict1.setKind(ConflictKind.PSEUDO);

		final Conflict pseudoConflict2 = FACTORY.createConflict();
		pseudoConflict2.setKind(ConflictKind.PSEUDO);

		final CompositeConflict pseudoCompositeConflict1 = new CompositeConflict(pseudoConflict1);
		assertEquals(ConflictKind.PSEUDO, pseudoCompositeConflict1.getKind());

		final CompositeConflict pseudoCompositeConflict2 = new CompositeConflict(pseudoConflict2);
		assertEquals(ConflictKind.PSEUDO, pseudoCompositeConflict2.getKind());

		// The union of pseudo conflicts results in a composite conflict with conflict kind pseudo
		pseudoCompositeConflict2.join(pseudoCompositeConflict1);
		final CompositeConflict mergedConflictGroup = pseudoCompositeConflict2;
		assertEquals(2, mergedConflictGroup.getConflicts().size());
		assertTrue(mergedConflictGroup.getConflicts().contains(pseudoConflict1));
		assertTrue(mergedConflictGroup.getConflicts().contains(pseudoConflict2));
		assertEquals(ConflictKind.PSEUDO, mergedConflictGroup.getKind());
	}

	/**
	 * Tests that a refined diff whose refinding diffs are involved in a real conflict
	 * {@link ConflictKind#REAL} is only shown in the conflicts group but not in the left or right diff group.
	 * This test is related to <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=501864"</a>
	 */
	@Test
	public void testRefinedDiffsWithRealConflictsAreOnlyInConflictGroup() {
		ConflictsGroupWithRefinedDiffTestScenario scenario = new ConflictsGroupWithRefinedDiffTestScenario();

		// Create real conflict between refining diffs
		final Conflict conflict = scenario.addConflict(scenario.diff1b, scenario.diff2b, ConflictKind.REAL);

		// Build conflict nodes
		final ConflictsGroupImpl conflictsGroup = buildConflictGroup(scenario.comparison);

		// One conflict node was created
		final List<? extends TreeNode> conflictNodes = conflictsGroup.getChildren();
		assertEquals(1, conflictNodes.size());

		// The conflict node is associated with the created conflict
		final ConflictNode conflictNode = (ConflictNode)conflictNodes.get(0);
		final CompositeConflict conflictNodeConflict = (CompositeConflict)conflictNode.basicGetData();
		assertEquals(1, conflictNodeConflict.getConflicts().size());
		assertTrue(conflictNodeConflict.getConflicts().contains(conflict));

		// The conflict node contains diff nodes for the refined diffs
		assertEquals(1, conflictNode.getChildren().size());
		final MatchNode matchNode = (MatchNode)conflictNode.getChildren().get(0);
		assertTrue(matchNodeContainsDiffNodesForDiffs(matchNode, scenario.diff1, scenario.diff2));

		// The technicalities filter does not filter this conflict, because there is a real conflict between
		// the refining diffs
		final List<? extends TreeNode> conflictDiffNodesFiltered = applyTechnicalitiesFilter(
				matchNode.getChildren());
		assertEquals(2, conflictDiffNodesFiltered.size());

		// Build left side
		final BasicDifferenceGroupImpl leftSide = buildDifferenceGroup(scenario.comparison,
				DifferenceSource.LEFT);

		// There are no diffs in the left side
		assertEquals(0, leftSide.getChildren().size());

		// Build right side
		final BasicDifferenceGroupImpl rightSide = buildDifferenceGroup(scenario.comparison,
				DifferenceSource.RIGHT);

		// There are no diffs in the right side
		assertEquals(0, rightSide.getChildren().size());
	}

	/**
	 * Tests that a refined diff whose refining diffs are involved in a real conflict
	 * {@link ConflictKind#REAL} and in a pseudo conflict {@link ConflictKind#REAL} is only shown in the
	 * conflicts group but not in the left or right diff group. This test is related to <a
	 * href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=501864"</a>
	 */
	@Test
	public void testRefinedDiffsWithRealAndPseudoConflictsAreOnlyInConflictGroup() {
		ConflictsGroupWithRefinedDiffTestScenario scenario = new ConflictsGroupWithRefinedDiffTestScenario();

		// Create real conflict between refining diffs
		final Conflict conflictReal = scenario.addConflict(scenario.diff1b, scenario.diff2b,
				ConflictKind.REAL);

		// Create pseudo conflict between refining diffs
		final Conflict conflictPseudo = scenario.addConflict(scenario.diff1a, scenario.diff2a,
				ConflictKind.PSEUDO);

		// Build conflict nodes
		final ConflictsGroupImpl conflictsGroup = buildConflictGroup(scenario.comparison);

		// One conflict node was created
		final List<? extends TreeNode> conflictNodes = conflictsGroup.getChildren();
		assertEquals(1, conflictNodes.size());

		// The conflict node is associated with the created conflicts
		final ConflictNode conflictNode = (ConflictNode)conflictNodes.get(0);
		final CompositeConflict conflictNodeConflict = (CompositeConflict)conflictNode.basicGetData();
		assertEquals(2, conflictNodeConflict.getConflicts().size());
		assertTrue(conflictNodeConflict.getConflicts().contains(conflictReal));
		assertTrue(conflictNodeConflict.getConflicts().contains(conflictPseudo));

		// The conflict node contains diff nodes for the refined diffs
		assertEquals(1, conflictNode.getChildren().size());
		final MatchNode matchNode = (MatchNode)conflictNode.getChildren().get(0);
		assertTrue(matchNodeContainsDiffNodesForDiffs(matchNode, scenario.diff1, scenario.diff2));

		// The technicalities filter does not filter this conflict, because there is a real conflict between
		// the refining diffs
		final List<? extends TreeNode> conflictDiffNodesFiltered = applyTechnicalitiesFilter(
				matchNode.getChildren());
		assertEquals(2, conflictDiffNodesFiltered.size());

		// Build left side
		final BasicDifferenceGroupImpl leftSide = buildDifferenceGroup(scenario.comparison,
				DifferenceSource.LEFT);

		// There are no diffs in the left side
		assertEquals(0, leftSide.getChildren().size());

		// Build right side
		final BasicDifferenceGroupImpl rightSide = buildDifferenceGroup(scenario.comparison,
				DifferenceSource.RIGHT);

		// There are no diffs in the right side
		assertEquals(0, rightSide.getChildren().size());
	}

	/**
	 * Tests that a refined diff that is refined by diffs who are all involved in pseudo conflicts
	 * {@link ConflictKind#REAL} is only shown in the conflicts group but not in the left or right diff group.
	 * This test is related to <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=501864"</a>
	 */
	@Test
	public void testRefinedDiffsWithOnlyPseudoConflictsAreOnlyInConflictGroup() {
		ConflictsGroupWithRefinedDiffTestScenario scenario = new ConflictsGroupWithRefinedDiffTestScenario();

		// Create pseudo conflicts between refining diffs
		final Conflict conflictPseudo1 = scenario.addConflict(scenario.diff1b, scenario.diff2b,
				ConflictKind.PSEUDO);
		final Conflict conflictPseudo2 = scenario.addConflict(scenario.diff1a, scenario.diff2a,
				ConflictKind.PSEUDO);

		// Build conflict nodes
		final ConflictsGroupImpl conflictsGroup = buildConflictGroup(scenario.comparison);

		// One conflict node was created
		final List<? extends TreeNode> conflictNodes = conflictsGroup.getChildren();
		assertEquals(1, conflictNodes.size());

		// The conflict node is associated with the created conflicts
		final ConflictNode conflictNode = (ConflictNode)conflictNodes.get(0);
		final CompositeConflict conflictNodeConflict = (CompositeConflict)conflictNode.basicGetData();
		assertEquals(2, conflictNodeConflict.getConflicts().size());
		assertTrue(conflictNodeConflict.getConflicts().contains(conflictPseudo1));
		assertTrue(conflictNodeConflict.getConflicts().contains(conflictPseudo2));

		// The conflict node contains diff nodes for the refined diffs
		assertEquals(1, conflictNode.getChildren().size());
		final MatchNode matchNode = (MatchNode)conflictNode.getChildren().get(0);
		assertTrue(matchNodeContainsDiffNodesForDiffs(matchNode, scenario.diff1, scenario.diff2));

		// The technicalities filter filters this conflict, since the involved refined diffs are refined by
		// diffs that are all involved in pseudo conflicts
		final List<? extends TreeNode> conflictDiffNodesFiltered = applyTechnicalitiesFilter(
				matchNode.getChildren());
		assertEquals(0, conflictDiffNodesFiltered.size());

		// Build left side
		final BasicDifferenceGroupImpl leftSide = buildDifferenceGroup(scenario.comparison,
				DifferenceSource.LEFT);

		// There are no diffs in the left side
		assertEquals(0, leftSide.getChildren().size());

		// Build right side
		final BasicDifferenceGroupImpl rightSide = buildDifferenceGroup(scenario.comparison,
				DifferenceSource.RIGHT);

		// There are no diffs in the right side
		assertEquals(0, rightSide.getChildren().size());
	}

	/**
	 * Tests that a refined diff that is refined by one diff involved in a pseudo conflict
	 * {@link ConflictKind#PSEUDO} and one diff involved in no conflict is shown only in the side group. This
	 * test is related to <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=501864"</a>
	 */
	@Test
	public void testRefinedDiffsWithOnlyOnePseudoConflictAreInDiffGroupOnly() {
		ConflictsGroupWithRefinedDiffTestScenario scenario = new ConflictsGroupWithRefinedDiffTestScenario();

		// Create pseudo conflict
		final Conflict conflictPseudo = scenario.addConflict(scenario.diff1b, scenario.diff2b,
				ConflictKind.PSEUDO);

		// Build conflict nodes
		final ConflictsGroupImpl conflictsGroup = buildConflictGroup(scenario.comparison);

		// One conflict node was created
		List<? extends TreeNode> conflictNodes = conflictsGroup.getChildren();
		assertEquals(1, conflictNodes.size());

		// The conflict node is associated with the created conflict
		ConflictNode conflictNode = (ConflictNode)conflictNodes.get(0);
		CompositeConflict conflictNodeConflict = (CompositeConflict)conflictNode.basicGetData();
		assertEquals(1, conflictNodeConflict.getConflicts().size());
		assertTrue(conflictNodeConflict.getConflicts().contains(conflictPseudo));

		// The conflict node contains diff nodes for the refined diffs
		assertEquals(1, conflictNode.getChildren().size());
		MatchNode matchNode = (MatchNode)conflictNode.getChildren().get(0);
		assertTrue(matchNodeContainsDiffNodesForDiffs(matchNode, scenario.diff1, scenario.diff2));

		// The technicalities filter does not filter this conflict, because it involved a refined diff that is
		// refined by a diff that is not involved in a conflict
		final List<? extends TreeNode> conflictDiffNodesFiltered = applyTechnicalitiesFilter(
				matchNode.getChildren());
		assertEquals(2, conflictDiffNodesFiltered.size());

		// Build left side
		final BasicDifferenceGroupImpl leftSide = buildDifferenceGroup(scenario.comparison,
				DifferenceSource.LEFT);

		// There is one refined diff in the left side, which is refined by one diff that is not in a conflict
		// and one diff that is in a PSEUDO conflict
		assertEquals(1, leftSide.getChildren().size());
		MatchNode matchNodeLeft = (MatchNode)leftSide.getChildren().get(0);
		assertTrue(matchNodeContainsDiffNodesForDiffs(matchNodeLeft, scenario.diff1));

		// The technicalities filter does not filter the changes on the left side, because the refined diff is
		// refined by a diff that is not involved in a conflict
		final List<? extends TreeNode> diffNodesLeftFiltered = applyTechnicalitiesFilter(
				matchNodeLeft.getChildren());
		assertEquals(1, diffNodesLeftFiltered.size());
		final List<? extends TreeNode> subDiffNodesLeftFiltered = applyTechnicalitiesFilter(
				diffNodesLeftFiltered.get(0).getChildren());
		assertEquals(1, subDiffNodesLeftFiltered.size());

		// Build right side
		final BasicDifferenceGroupImpl rightSide = buildDifferenceGroup(scenario.comparison,
				DifferenceSource.RIGHT);

		// There is one refined diff in the right side, which is refined by one diff that is not in a conflict
		// and one diff that is in a PSEUDO conflict
		assertEquals(1, rightSide.getChildren().size());
		MatchNode matchNodeRight = (MatchNode)rightSide.getChildren().get(0);
		assertTrue(matchNodeContainsDiffNodesForDiffs(matchNodeRight, scenario.diff2));

		// The technicalities filter does not filter the changes on the right side, because the refined diff
		// is refined by a diff that is not involved in a conflict
		final List<? extends TreeNode> diffNodesRightFiltered = applyTechnicalitiesFilter(
				matchNodeRight.getChildren());
		assertEquals(1, diffNodesRightFiltered.size());
		final List<? extends TreeNode> subDiffNodesRightFiltered = applyTechnicalitiesFilter(
				diffNodesRightFiltered.get(0).getChildren());
		assertEquals(1, subDiffNodesRightFiltered.size());
	}

	/**
	 * Tests that a refined diff that is directly involved in a pseudo conflict {@link ConflictKind#PSEUDO}
	 * and that is refined by one diff involved in a real conflict {@link ConflictKind#REAL} is shown in the
	 * conflicts group. This test is related to <a
	 * href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=501864"</a>
	 */
	@Test
	public void testRefinedDiffsInPseudoConflictAndWithRefiningDiffsInRealConflictAreInConflictGroup() {
		ConflictsGroupWithRefinedDiffTestScenario scenario = new ConflictsGroupWithRefinedDiffTestScenario();

		// Create pseudo conflict
		final Conflict conflictPseudo = scenario.addConflict(scenario.diff1, scenario.diff2,
				ConflictKind.PSEUDO);

		// Create real conflict
		final Conflict conflictReal = scenario.addConflict(scenario.diff1b, scenario.diff2b,
				ConflictKind.REAL);

		// Build conflict nodes
		final ConflictsGroupImpl conflictsGroup = buildConflictGroup(scenario.comparison);

		// One conflict node was created
		List<? extends TreeNode> conflictNodes = conflictsGroup.getChildren();
		assertEquals(1, conflictNodes.size());

		// The conflict node is associated with both created conflicts
		ConflictNode conflictNode = (ConflictNode)conflictNodes.get(0);
		CompositeConflict conflictNodeConflict = (CompositeConflict)conflictNode.basicGetData();
		assertEquals(2, conflictNodeConflict.getConflicts().size());
		assertTrue(conflictNodeConflict.getConflicts().contains(conflictPseudo));
		assertTrue(conflictNodeConflict.getConflicts().contains(conflictReal));

		// The conflict node contains diff nodes for the refined diffs
		assertEquals(1, conflictNode.getChildren().size());
		MatchNode matchNode = (MatchNode)conflictNode.getChildren().get(0);
		assertTrue(matchNodeContainsDiffNodesForDiffs(matchNode, scenario.diff1, scenario.diff2));

		// The technicalities filter does not filter this conflict, because there is a real conflict between
		// the refining diffs
		final List<? extends TreeNode> conflictDiffNodesFiltered = applyTechnicalitiesFilter(
				matchNode.getChildren());
		assertEquals(2, conflictDiffNodesFiltered.size());

		// Build left side
		final BasicDifferenceGroupImpl leftSide = buildDifferenceGroup(scenario.comparison,
				DifferenceSource.LEFT);

		// There are no diffs in the left side
		assertEquals(0, leftSide.getChildren().size());

		// Build right side
		final BasicDifferenceGroupImpl rightSide = buildDifferenceGroup(scenario.comparison,
				DifferenceSource.RIGHT);

		// There are no diffs in the right side
		assertEquals(0, rightSide.getChildren().size());
	}

	/**
	 * Tests that a refined diff that is neither directly nor indirect involved in any conflict is shown in
	 * the left or right diff group. This test is related to <a
	 * href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=501864"</a>
	 */
	@Test
	public void testRefinedDiffsWithoutConfictsAreInDiffGroup() {
		ConflictsGroupWithRefinedDiffTestScenario scenario = new ConflictsGroupWithRefinedDiffTestScenario();

		// Build conflict nodes
		final ConflictsGroupImpl conflictsGroup = buildConflictGroup(scenario.comparison);

		// No conflict node was created
		assertEquals(0, conflictsGroup.getChildren().size());

		// Build left side
		final BasicDifferenceGroupImpl leftSide = buildDifferenceGroup(scenario.comparison,
				DifferenceSource.LEFT);

		// There is one refined diff in the left side, which is neither directly nor indirectly involved in a
		// conflict
		assertEquals(1, leftSide.getChildren().size());
		MatchNode matchNodeLeft = (MatchNode)leftSide.getChildren().get(0);
		assertTrue(matchNodeContainsDiffNodesForDiffs(matchNodeLeft, scenario.diff1));

		// The technicalities filter does not filter the changes on the left side, because they are not
		// involved in conflicts
		final List<? extends TreeNode> diffNodesLeftFiltered = applyTechnicalitiesFilter(
				matchNodeLeft.getChildren());
		assertEquals(1, diffNodesLeftFiltered.size());
		final List<? extends TreeNode> subDiffNodesLeftFiltered = applyTechnicalitiesFilter(
				diffNodesLeftFiltered.get(0).getChildren());
		assertEquals(2, subDiffNodesLeftFiltered.size());

		// Build right side
		final BasicDifferenceGroupImpl rightSide = buildDifferenceGroup(scenario.comparison,
				DifferenceSource.RIGHT);

		// There is one refined diff in the right side, which is neither directly nor indirectly involved in a
		// conflict
		assertEquals(1, rightSide.getChildren().size());
		MatchNode matchNodeRight = (MatchNode)rightSide.getChildren().get(0);
		assertTrue(matchNodeContainsDiffNodesForDiffs(matchNodeRight, scenario.diff2));

		// The technicalities filter does not filter the changes on the right side, because they are not
		// involved in conflicts
		final List<? extends TreeNode> diffNodesRightFiltered = applyTechnicalitiesFilter(
				matchNodeRight.getChildren());
		assertEquals(1, diffNodesRightFiltered.size());
		final List<? extends TreeNode> subDiffNodesRightFiltered = applyTechnicalitiesFilter(
				diffNodesRightFiltered.get(0).getChildren());
		assertEquals(2, subDiffNodesRightFiltered.size());

	}

	private class TestECrossReferenceAdapter extends ECrossReferenceAdapter {
		/**
		 * {@inheritDoc}
		 * 
		 * @see org.eclipse.emf.ecore.util.ECrossReferenceAdapter#isIncluded(org.eclipse.emf.ecore.EReference)
		 */
		@Override
		protected boolean isIncluded(EReference eReference) {
			return eReference == TreePackage.Literals.TREE_NODE__DATA;
		}
	}

	private ConflictsGroupImpl buildConflictGroup(Comparison comparison) {
		final ConflictsGroupImpl conflictsGroup = new ConflictsGroupImpl(comparison,
				EMFCompareRCPUIMessages.getString("ThreeWayComparisonGroupProvider.conflicts.label"), //$NON-NLS-1$
				crossReferenceAdapter);
		conflictsGroup.buildSubTree();
		return conflictsGroup;
	}

	private BasicDifferenceGroupImpl buildDifferenceGroup(Comparison comparison, DifferenceSource source) {
		final BasicDifferenceGroupImpl differenceGroup = new BasicDifferenceGroupImpl(comparison,
				and(fromSide(source), ThreeWayComparisonGroupProvider.DEFAULT_DIFF_GROUP_FILTER_PREDICATE),
				"", crossReferenceAdapter);
		differenceGroup.buildSubTree();
		return differenceGroup;
	}

	private boolean matchNodeContainsDiffNodesForDiffs(MatchNode matchNode, Diff... diffs) {
		final boolean matchNodeContainsRightAmountOfChildren = matchNode.getChildren().size() == diffs.length;
		boolean matchNodeContainsDiffNodesForDiffs = true;
		for (Diff diff : diffs) {
			DiffNode diffNode = getDiffNode(matchNode.getChildren(), diff);
			if (!isDiffNodeForDiff(diffNode, diff)) {
				matchNodeContainsDiffNodesForDiffs = false;
			}
		}
		return matchNodeContainsRightAmountOfChildren && matchNodeContainsDiffNodesForDiffs;
	}

	private DiffNode getDiffNode(EList<TreeNode> nodes, Diff diff) {
		for (TreeNode node : nodes) {
			if (node instanceof DiffNode) {
				DiffNode diffNode = (DiffNode)node;
				if (diffNode.basicGetData() == diff) {
					return diffNode;
				}
			}
		}
		return null;
	}

	private boolean isDiffNodeForDiff(DiffNode diffNode, Diff diff) {
		if (diffNode == null || diff == null) {
			return false;
		}
		final boolean diffNodeAssociatedWithDiff = diffNode.basicGetData() == diff;
		final boolean diffNodeContainsRightAmountOfChildren = diffNode.getChildren().size() == diff
				.getRefinedBy().size();
		boolean diffNodeContainsNodesForRefiningDiffs = true;
		for (Diff refiningDiff : diff.getRefinedBy()) {
			final DiffNode diffNodeForRefiningDiff = getDiffNode(diffNode.getChildren(), refiningDiff);
			if (diffNodeForRefiningDiff == null) {
				diffNodeContainsNodesForRefiningDiffs = false;
			}
		}
		return diffNodeAssociatedWithDiff && diffNodeContainsRightAmountOfChildren
				&& diffNodeContainsNodesForRefiningDiffs;
	}

	private List<? extends TreeNode> applyTechnicalitiesFilter(List<? extends TreeNode> actualTrees) {
		final StructureMergeViewerFilter filter = new StructureMergeViewerFilter(new EventBus());
		final TechnicalitiesFilter technicalitiesFilter = new TechnicalitiesFilter();
		filter.addFilter(technicalitiesFilter);
		Predicate<EObject> viewerFilterPredicate = new Predicate<EObject>() {
			public boolean apply(EObject input) {
				AdapterImpl adapter = new AdapterImpl();
				adapter.setTarget(input);
				return filter.select(null, null, adapter);
			}
		};
		List<? extends TreeNode> filteredTrees = Lists
				.newArrayList(Collections2.filter(actualTrees, viewerFilterPredicate));
		return filteredTrees;
	}
}