/*******************************************************************************
 * Copyright (c) 2017 EclipseSource Services GmbH 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:
 *      Martin Fleck - initial API and implementation
 *      Philip Langer - bug 527858
 *******************************************************************************/
package org.eclipse.emf.compare.rcp.ui.tests.mergeviewer;

import static org.eclipse.emf.compare.rcp.ui.mergeviewer.IMergeViewer.MergeViewerSide.LEFT;
import static org.eclipse.emf.compare.rcp.ui.mergeviewer.IMergeViewer.MergeViewerSide.RIGHT;

import org.eclipse.emf.compare.Conflict;
import org.eclipse.emf.compare.ConflictKind;
import org.eclipse.emf.compare.Diff;
import org.eclipse.emf.compare.internal.spec.ConflictSpec;
import org.eclipse.emf.compare.internal.spec.DiffSpec;
import org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.impl.AbstractTableOrTreeMergeViewer;
import org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.item.impl.MergeViewerItem;
import org.eclipse.emf.compare.rcp.ui.mergeviewer.IMergeViewer.MergeViewerSide;
import org.eclipse.emf.compare.rcp.ui.mergeviewer.item.IMergeViewerItem;
import org.eclipse.jface.viewers.IElementComparer;
import org.junit.Assert;
import org.junit.Test;

/**
 * Tests the quality of merge viewer items in the table and tree content merge viewer. Specifically, this
 * class tests the following requirements:
 * <ul>
 * <li>For pseudo conflicts, we only compare the ancestor side value and the conflict.</li>
 * <li>If neither item has a left or right side value, we only compare their diffs.</li>
 * <li>If only one item has a diff, we only compare the left, right, and ancestor side values.</li>
 * <li>If there is no special handling, we compare everything (left, right, ancestor, diff).</li>
 * <li>For Non-MergeViewerItems use normal object equality.</li>
 * </ul>
 * 
 * @author Martin Fleck <mfleck@eclipsesource.com>
 */
@SuppressWarnings({"restriction", "nls" })
public class TableOrTreeMergeViewerElementComparerTest {
	/** Stateless element comparer: Handles EMF Compare Viewer Items and defaults to Objects.equal(). */
	private static final IElementComparer ELEMENT_COMPARER = new AbstractTableOrTreeMergeViewer.ElementComparer();

	/**
	 * <p>
	 * Requirement: For pseudo conflicts, we only compare the ancestor side value and the conflict.
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      | aLeft      | bLeft      |
	 * ----------+------------+------------+
	 * Right     | aRight     | bRight     |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      | aDiff      | bDiff      |
	 * ----------+------------+------------+
	 * Conflict  |       Equal PSEUDO      |
	 * ----------+------------+------------+
	 * 
	 * Expected: Equal (special treatment of pseudo conflicts)
	 * </pre>
	 */
	@Test
	public void testEqualPseudoConflictEqualAncestor() {
		Conflict pseudoConflict = createConflict(ConflictKind.PSEUDO);

		Diff aDiff = createDiff(pseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "aLeft", "aRight", "Ancestor");

		Diff bDiff = createDiff(pseudoConflict);
		IMergeViewerItem rightItem = createItem(RIGHT, bDiff, "bLeft", "bRight", "Ancestor");

		assertEquals(leftItem, rightItem, true);
	}

	/**
	 * <p>
	 * Requirement: For pseudo conflicts, we only compare the ancestor side value and the conflict.
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      | aLeft      | bLeft      |
	 * ----------+------------+------------+
	 * Right     | aRight     | bRight     |
	 * ----------+------------+------------+
	 * Ancestor  | aAncestor  | bAncestor  |
	 * ----------+------------+------------+
	 * Diff      | aDiff      | bDiff      |
	 * ----------+------------+------------+
	 * Conflict  |       Equal PSEUDO      |
	 * ----------+------------+------------+
	 * 
	 * Expected: Not Equal (unequal ancestors, so no special treatment of pseudo conflict)
	 * </pre>
	 * 
	 * @see #testEqualPseudoConflictEqualAncestor()
	 */
	@Test
	public void testEqualPseudoConflictUnequalAncestor() {
		Conflict pseudoConflict = createConflict(ConflictKind.PSEUDO);

		Diff aDiff = createDiff(pseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "aLeft", "aRight", "aAncestor");

		Diff bDiff = createDiff(pseudoConflict);
		IMergeViewerItem rightItem = createItem(RIGHT, bDiff, "bLeft", "bRight", "bAncestor");

		assertEquals(leftItem, rightItem, false);
	}

	/**
	 * <p>
	 * Requirement: For pseudo conflicts, we only compare the ancestor side value and the conflict.
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      | aLeft      | bLeft      |
	 * ----------+------------+------------+
	 * Right     | aRight     | bRight     |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      | aDiff      | bDiff      |
	 * ----------+------------+------------+
	 * Conflict  | aPseudo    | bPseudo    |
	 * ----------+------------+------------+
	 * 
	 * Expected: Not Equal (unequal conflicts, so no special treatment of pseudo conflict)
	 * </pre>
	 * 
	 * @see #testEqualPseudoConflictEqualAncestor()
	 */
	@Test
	public void testUnequalPseudoConflictEqualAncestor() {
		Conflict aPseudo = createConflict(ConflictKind.PSEUDO);
		Diff aDiff = createDiff(aPseudo);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "aLeft", "aRight", "Ancestor");

		Conflict bPseudo = createConflict(ConflictKind.PSEUDO);
		Diff bDiff = createDiff(bPseudo);
		IMergeViewerItem rightItem = createItem(RIGHT, bDiff, "bLeft", "bRight", "Ancestor");

		assertEquals(leftItem, rightItem, false);
	}

	/**
	 * <p>
	 * Requirement: For pseudo conflicts, we only compare the ancestor side value and the conflict.
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      | aLeft      | bLeft      |
	 * ----------+------------+------------+
	 * Right     | aRight     | bRight     |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      | aDiff      | bDiff      |
	 * ----------+------------+------------+
	 * Conflict  |        Equal REAL       |
	 * ----------+------------+------------+
	 * 
	 * Expected: Not Equal (no special treatment for real conflicts)
	 * </pre>
	 * 
	 * @see #testEqualPseudoConflictEqualAncestor()
	 */
	@Test
	public void testEqualRealConflictEqualAncestor() {
		Conflict pseudoConflict = createConflict(ConflictKind.REAL);

		Diff aDiff = createDiff(pseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "aLeft", "aRight", "Ancestor");

		Diff bDiff = createDiff(pseudoConflict);
		IMergeViewerItem rightItem = createItem(RIGHT, bDiff, "bLeft", "bRight", "Ancestor");

		assertEquals(leftItem, rightItem, false);
	}

	/**
	 * <p>
	 * Requirement: If neither item has a left or right side value, we only compare their diffs.
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      | null       | null       |
	 * ----------+------------+------------+
	 * Right     | null       | null       |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      |          Equal          |
	 * ----------+------------+------------+
	 * Conflict  |        Equal REAL       |
	 * ----------+------------+------------+
	 * 
	 * Expected: Equal (left and right item use equal diffs)
	 * </pre>
	 */
	@Test
	public void testNullSidesEqualDiff() {
		Conflict pseudoConflict = createConflict(ConflictKind.REAL);
		Diff diff = createDiff(pseudoConflict);

		IMergeViewerItem leftItem = createItem(LEFT, diff, null, null, "Ancestor");
		IMergeViewerItem rightItem = createItem(RIGHT, diff, null, null, "Ancestor");

		assertEquals(leftItem, rightItem, true);
	}

	/**
	 * <p>
	 * Requirement: If neither item has a left or right side value, we only compare their diffs.
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      | null       | null       |
	 * ----------+------------+------------+
	 * Right     | null       | null       |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      | aDiff      | bDiff      |
	 * ----------+------------+------------+
	 * Conflict  |        Equal REAL       |
	 * ----------+------------+------------+
	 * 
	 * Expected: Not Equal (left and right item use unequal diffs)
	 * </pre>
	 */
	@Test
	public void testNullSidesUnequalDiff() {
		Conflict pseudoConflict = createConflict(ConflictKind.REAL);

		Diff aDiff = createDiff(pseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, null, null, "Ancestor");

		Diff bDiff = createDiff(pseudoConflict);
		IMergeViewerItem rightItem = createItem(RIGHT, bDiff, null, null, "Ancestor");

		assertEquals(leftItem, rightItem, false);
	}

	/**
	 * <p>
	 * Requirement: If only one item has a diff, we only compare the left, right, and ancestor side values.
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      |          Equal          |
	 * ----------+------------+------------+
	 * Right     |          Equal          |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      | aDiff      | null       |
	 * ----------+------------+------------+
	 * Conflict  |          REAL           |
	 * ----------+------------+------------+
	 * 
	 * Expected: Equal (left, right and ancestor side values are equal)
	 * </pre>
	 */
	@Test
	public void testOnlyOneSideDiffEqualLeftRightAncestor() {
		Conflict pseudoConflict = createConflict(ConflictKind.REAL);
		Diff aDiff = createDiff(pseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "Left", "Right", "Ancestor");

		IMergeViewerItem rightItem = createItem(RIGHT, null, "Left", "Right", "Ancestor");

		assertEquals(leftItem, rightItem, true);
	}

	/**
	 * <p>
	 * Requirement: If only one item has a diff, we only compare the left, right, and ancestor side values.
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      | aLeft      | bLeft      |
	 * ----------+------------+------------+
	 * Right     |          Equal          |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      | aDiff      | null       |
	 * ----------+------------+------------+
	 * Conflict  |          REAL           |
	 * ----------+------------+------------+
	 * 
	 * Expected: Not Equal (left side values not equal)
	 * </pre>
	 */
	@Test
	public void testOnlyOneSideDiffEqualRightAncestorUnequalLeft() {
		Conflict pseudoConflict = createConflict(ConflictKind.REAL);
		Diff aDiff = createDiff(pseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "aLeft", "Right", "Ancestor");

		IMergeViewerItem rightItem = createItem(RIGHT, null, "bLeft", "Right", "Ancestor");

		assertEquals(leftItem, rightItem, false);
	}

	/**
	 * <p>
	 * Requirement: If only one item has a diff, we only compare the left, right, and ancestor side values.
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      |          Equal          |
	 * ----------+------------+------------+
	 * Right     | aRight     | bRight     |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      | aDiff      | null       |
	 * ----------+------------+------------+
	 * Conflict  |          REAL           |
	 * ----------+------------+------------+
	 * 
	 * Expected: Not Equal (right side values not equal)
	 * </pre>
	 */
	@Test
	public void testOnlyOneSideDiffEqualLeftAncestorUnequalRight() {
		Conflict pseudoConflict = createConflict(ConflictKind.REAL);
		Diff aDiff = createDiff(pseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "Left", "aRight", "Ancestor");

		IMergeViewerItem rightItem = createItem(RIGHT, null, "Left", "bRight", "Ancestor");

		assertEquals(leftItem, rightItem, false);
	}

	/**
	 * <p>
	 * Requirement: If only one item has a diff, we only compare the left, right, and ancestor side values.
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      |          Equal          |
	 * ----------+------------+------------+
	 * Right     |          Equal          |
	 * ----------+------------+------------+
	 * Ancestor  | aAncestor  | bAncestor  |
	 * ----------+------------+------------+
	 * Diff      | aDiff      | null       |
	 * ----------+------------+------------+
	 * Conflict  |          REAL           |
	 * ----------+------------+------------+
	 * 
	 * Expected: Not Equal (ancestor side values not equal)
	 * </pre>
	 */
	@Test
	public void testOnlyOneSideDiffEqualLeftRightUnequalAncestor() {
		Conflict pseudoConflict = createConflict(ConflictKind.REAL);
		Diff aDiff = createDiff(pseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "Left", "Right", "aAncestor");

		IMergeViewerItem rightItem = createItem(RIGHT, null, "Left", "Right", "bAncestor");

		assertEquals(leftItem, rightItem, false);
	}

	/**
	 * <p>
	 * Requirement: If there is no special handling, we compare everything (left, right, ancestor, diff).
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      |          Equal          |
	 * ----------+------------+------------+
	 * Right     |          Equal          |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      |          Equal          |
	 * ----------+------------+------------+
	 * Conflict  |        Equal REAL       |
	 * ----------+------------+------------+
	 * 
	 * Expected: Equal (left, right, ancestor and diff are equal)
	 * </pre>
	 */
	@Test
	public void testAllEqual() {
		Conflict pseudoConflict = createConflict(ConflictKind.REAL);
		Diff aDiff = createDiff(pseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "Left", "Right", "Ancestor");
		IMergeViewerItem rightItem = createItem(RIGHT, aDiff, "Left", "Right", "Ancestor");

		assertEquals(leftItem, rightItem, true);
	}

	/**
	 * <p>
	 * Requirement: If there is no special handling, we compare everything (left, right, ancestor, diff).
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      |          Equal          |
	 * ----------+------------+------------+
	 * Right     |          Equal          |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      | aDiff      | bDiff      |
	 * ----------+------------+------------+
	 * Conflict  | a REAL     | b REAL     |
	 * ----------+------------+------------+
	 * 
	 * Expected: Not Equal (diffs not equal)
	 * </pre>
	 */
	@Test
	public void testAllEqualExceptDiffWithDifferentConflict() {
		Conflict aPseudoConflict = createConflict(ConflictKind.REAL);
		Conflict bPseudoConflict = createConflict(ConflictKind.REAL);

		Diff aDiff = createDiff(aPseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "Left", "Right", "Ancestor");

		Diff bDiff = createDiff(bPseudoConflict);
		IMergeViewerItem rightItem = createItem(RIGHT, bDiff, "Left", "Right", "Ancestor");

		assertEquals(leftItem, rightItem, false);
	}

	/**
	 * <p>
	 * Requirement: If there is no special handling, we compare everything (left, right, ancestor, diff).
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      |          Equal          |
	 * ----------+------------+------------+
	 * Right     |          Equal          |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      | aDiff      | bDiff      |
	 * ----------+------------+------------+
	 * Conflict  |        Equal REAL       |
	 * ----------+------------+------------+
	 * 
	 * Expected: Not Equal (diffs not equal)
	 * </pre>
	 */
	@Test
	public void testAllEqualIncludingDiffWithSameConflict() {
		Conflict conflict = createConflict(ConflictKind.REAL);

		Diff aDiff = createDiff(conflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "Left", "Right", "Ancestor");

		Diff bDiff = createDiff(conflict);
		IMergeViewerItem rightItem = createItem(RIGHT, bDiff, "Left", "Right", "Ancestor");

		assertEquals(leftItem, rightItem, true);
	}

	/**
	 * <p>
	 * Requirement: If there is no special handling, we compare everything (left, right, ancestor, diff).
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      | aLeft      | bLeft      |
	 * ----------+------------+------------+
	 * Right     |          Equal          |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      |          Equal          |
	 * ----------+------------+------------+
	 * Conflict  |        Equal REAL       |
	 * ----------+------------+------------+
	 * 
	 * Expected: Not Equal (left values not equal)
	 * </pre>
	 */
	@Test
	public void testAllEqualExceptLeft() {
		Conflict pseudoConflict = createConflict(ConflictKind.REAL);
		Diff aDiff = createDiff(pseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "aLeft", "Right", "Ancestor");
		IMergeViewerItem rightItem = createItem(RIGHT, aDiff, "bLeft", "Right", "Ancestor");

		assertEquals(leftItem, rightItem, false);
	}

	/**
	 * <p>
	 * Requirement: If there is no special handling, we compare everything (left, right, ancestor, diff).
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      |          Equal          |
	 * ----------+------------+------------+
	 * Right     | aRight     | bRight     |
	 * ----------+------------+------------+
	 * Ancestor  |          Equal          |
	 * ----------+------------+------------+
	 * Diff      |          Equal          |
	 * ----------+------------+------------+
	 * Conflict  |        Equal REAL       |
	 * ----------+------------+------------+
	 * 
	 * Expected: Not Equal (right values not equal)
	 * </pre>
	 */
	@Test
	public void testAllEqualExceptRight() {
		Conflict pseudoConflict = createConflict(ConflictKind.REAL);
		Diff aDiff = createDiff(pseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "Left", "aRight", "Ancestor");
		IMergeViewerItem rightItem = createItem(RIGHT, aDiff, "Left", "bRight", "Ancestor");

		assertEquals(leftItem, rightItem, false);
	}

	/**
	 * <p>
	 * Requirement: If there is no special handling, we compare everything (left, right, ancestor, diff).
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      |          Equal          |
	 * ----------+------------+------------+
	 * Right     |          Equal          |
	 * ----------+------------+------------+
	 * Ancestor  | aAncestor  | bAncestor  |
	 * ----------+------------+------------+
	 * Diff      |          Equal          |
	 * ----------+------------+------------+
	 * Conflict  |        Equal REAL       |
	 * ----------+------------+------------+
	 * 
	 * Expected: Not Equal (ancestor values not equal)
	 * </pre>
	 */
	@Test
	public void testAllEqualExceptAncestor() {
		Conflict pseudoConflict = createConflict(ConflictKind.REAL);
		Diff aDiff = createDiff(pseudoConflict);
		IMergeViewerItem leftItem = createItem(LEFT, aDiff, "Left", "Right", "aAncestor");
		IMergeViewerItem rightItem = createItem(RIGHT, aDiff, "Left", "Right", "bAncestor");

		assertEquals(leftItem, rightItem, false);
	}

	/**
	 * <p>
	 * Requirement: If there is no special handling, we compare everything (left, right, ancestor, diff).
	 * </p>
	 * Tests the equality of two items using the following setup:
	 * 
	 * <pre>
	 *           |   Item A   |  Item B    |
	 * ----------+------------+------------+
	 * Left      |       Equal Null        |
	 * ----------+------------+------------+
	 * Right     |       Equal Null        |
	 * ----------+------------+------------+
	 * Ancestor  |       Equal Null        |
	 * ----------+------------+------------+
	 * Diff      |       Equal Null        |
	 * ----------+------------+------------+
	 * Conflict  |            -            |
	 * ----------+------------+------------+
	 * 
	 * Expected: Equal (left, right, ancestor and diff are equal)
	 * </pre>
	 */
	@Test
	public void testAllEqualNull() {
		IMergeViewerItem leftItem = createItem(LEFT, null, null, null, null);
		IMergeViewerItem rightItem = createItem(RIGHT, null, null, null, null);

		assertEquals(leftItem, rightItem, true);
	}

	/**
	 * <p>
	 * Requirement: For Non-MergeViewerItems, use normal object equality.
	 * </p>
	 */
	@Test
	public void testFallbackSameObject() {
		String left = "a";
		assertEquals(left, left, true);
	}

	/**
	 * <p>
	 * Requirement: For Non-MergeViewerItems, use normal object equality.
	 * </p>
	 */
	@Test
	public void testFallbackEqualObject() {
		String left = "a";
		String right = "a";
		assertEquals(left, right, true);
	}

	/**
	 * <p>
	 * Requirement: For Non-MergeViewerItems, use normal object equality.
	 * </p>
	 */
	@Test
	public void testFallbackUnequalObjects() {
		String left = "a";
		String right = "b";
		assertEquals(left, right, false);
	}

	/**
	 * Creates a new conflict with the given conflict kind.
	 * 
	 * @param kind
	 *            conflict kind
	 * @return a new conflict instance
	 */
	protected Conflict createConflict(ConflictKind kind) {
		Conflict conflict = new ConflictSpec();
		conflict.setKind(kind);
		return conflict;
	}

	/**
	 * Creates a new diff with the given conflict set.
	 * 
	 * @param conflict
	 *            conflict
	 * @return a new diff instance
	 */
	protected Diff createDiff(Conflict conflict) {
		Diff diff = new DiffSpec();
		diff.setConflict(conflict);
		return diff;
	}

	/**
	 * Creates a new merge viewer item.
	 * 
	 * @param side
	 *            merge viewer side
	 * @param diff
	 *            diff
	 * @param left
	 *            value of the left side
	 * @param right
	 *            value of the right side
	 * @param ancestor
	 *            value of the ancestor side
	 * @return a new merge viewer item instance
	 */
	protected IMergeViewerItem createItem(MergeViewerSide side, Diff diff, final Object left,
			final Object right, final Object ancestor) {
		IMergeViewerItem item = new MergeViewerItem(null, diff, left, right, ancestor, side, null) {
			@Override
			public String toString() {
				return left + " - " + right + " - " + ancestor;
			}
		};
		return item;
	}

	/**
	 * Asserts that the given objects have the expected equality relation in both directions.
	 * 
	 * <pre>
	 * expected == (a equals b) == (b equals a)
	 * </pre>
	 * 
	 * @param a
	 *            element
	 * @param b
	 *            element
	 * @param expected
	 *            expected equality
	 */
	@SuppressWarnings({"boxing" })
	protected void assertEquals(Object a, Object b, boolean expected) {
		Assert.assertEquals("{" + a + "} equals {" + b + "}.", expected, ELEMENT_COMPARER.equals(a, b));
		Assert.assertEquals("{" + b + "} equals {" + a + "}.", expected, ELEMENT_COMPARER.equals(b, a));
	}
}