DiffUtilTest.java

/*******************************************************************************
 * Copyright (c) 2012, 2014 Obeo.
 * 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
 *******************************************************************************/
package org.eclipse.emf.compare.tests.diff;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import com.google.common.collect.Lists;

import java.util.Collections;
import java.util.List;

import org.eclipse.emf.compare.CompareFactory;
import org.eclipse.emf.compare.Comparison;
import org.eclipse.emf.compare.internal.utils.DiffUtil;
import org.junit.Test;

/**
 * We will use this to test the utility methods exposed by the {@link DiffUtil}.
 * 
 * @author <a href="mailto:laurent.goubet@obeo.fr">Laurent Goubet</a>
 */
@SuppressWarnings("all")
public class DiffUtilTest {
	@Test
	public void lcsTest1() {
		final List<Character> left = Lists.charactersOf("abcde");
		final List<Character> right = Lists.charactersOf("czdab");

		final Comparison emptyComparison = createEmptyComparison();
		final List<Character> lcs = DiffUtil.longestCommonSubsequence(emptyComparison, left, right);

		/*
		 * This is documented in {@link DefaultDiffEngine#longestCommonSubsequence(Comparison, List, List)}.
		 * Ensure the documentation stays in sync.
		 */
		assertEqualContents(Lists.charactersOf("cd"), lcs);
	}

	@Test
	public void lcsTest2() {
		final List<Character> left = Lists.charactersOf("abcde");
		final List<Character> right = Lists.charactersOf("ycdeb");

		final Comparison emptyComparison = createEmptyComparison();
		final List<Character> lcs = DiffUtil.longestCommonSubsequence(emptyComparison, left, right);

		/*
		 * This is documented in {@link DiffUtil#longestCommonSubsequence(Comparison, List, List)}. Ensure the
		 * documentation stays in sync.
		 */
		assertEqualContents(Lists.charactersOf("cde"), lcs);
	}

	@Test
	public void lcsTest3() {
		final List<Integer> left = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7);
		final List<Integer> right = Lists.newArrayList(8, 9, 2, 3, 4, 1, 0);

		final Comparison emptyComparison = createEmptyComparison();
		final List<Integer> lcs = DiffUtil.longestCommonSubsequence(emptyComparison, left, right);

		// These are the origin and left sides of the "complex" conflict test case.
		assertEqualContents(Lists.newArrayList(2, 3, 4), lcs);
	}

	@Test
	public void lcsTest4() {
		final List<Integer> left = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7);
		final List<Integer> right = Lists.newArrayList(6, 2, 9, 3, 0, 4, 1, 7);

		final Comparison emptyComparison = createEmptyComparison();
		final List<Integer> lcs = DiffUtil.longestCommonSubsequence(emptyComparison, left, right);

		// These are the origin and right sides of the "complex" conflict test case.
		assertEqualContents(Lists.newArrayList(2, 3, 4, 7), lcs);
	}

	@Test
	public void lcsTest5() {
		final List<Integer> left = Collections.EMPTY_LIST;
		final List<Integer> right = Collections.EMPTY_LIST;

		final Comparison emptyComparison = createEmptyComparison();
		final List<Integer> lcs = DiffUtil.longestCommonSubsequence(emptyComparison, left, right);

		assertEqualContents(Collections.EMPTY_LIST, lcs);
	}

	@Test
	public void lcsTest6() {
		final List<Integer> left = Lists.newArrayList(1, 2, null, 4, 5, null, 7);
		final List<Integer> right = Lists.newArrayList(6, 2, 9, null, null, 4, 1, 7);

		final Comparison emptyComparison = createEmptyComparison();
		final List<Integer> lcs = DiffUtil.longestCommonSubsequence(emptyComparison, left, right);

		// These are the origin and right sides of the "complex" conflict test case.
		assertEqualContents(Lists.newArrayList(2, null, null, 7), lcs);
	}

	@Test
	public void insertionIndexTest1() {
		// Assume "left" is {8, 9, 2, 3, 4, 1, 0, 6}
		// Assume "right" is {6, 2, 9, 3, 0, 4, 7}
		// We'll transition "right" into "left" by "merging" the additions one after another.
		// We'll assume the user merges all from left to right, fixing conflicts by "undoing" changes in right

		// We'll go through the following changes :
		// add "1" in right = {6, 2, 9, 3, 1, 0, 4, 7}
		// remove 9 from right = {6, 2, 3, 1, 0, 4, 7}
		// add "9" in right = {6, 9, 2, 3, 1, 0, 4, 7}
		// remove "0" from right = {6, 9, 2, 3, 1, 4, 7}
		// add "0" in right = {6, 9, 2, 3, 1, 0, 4, 7}
		// add "8" in right = {6, 8, 9, 2, 3, 1, 0, 4, 7}
		// remove "7" from right = {6, 8, 9, 2, 3, 1, 0, 4}
		// remove "4" from right = {6, 8, 9, 2, 3, 1, 0}
		// add "4" in right = {6, 8, 9, 2, 3, 4, 1, 0}
		// remove "6" from right = {8, 9, 2, 3, 4, 1, 0}
		// add "6" in right = {8, 9, 2, 3, 4, 1, 0, 6}

		final List<Integer> left = Lists.newArrayList(8, 9, 2, 3, 4, 1, 0, 6);
		final Comparison emptyComparison = createEmptyComparison();

		// Merge the move of "1" (assume 1 already removed from right)
		List<Integer> right = Lists.newArrayList(6, 2, 9, 3, 0, 4, 7);
		int insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(1));
		// Inserted just before "0"
		assertEquals(4, insertionIndex);

		// Merge the move of "9" (assume 9 already removed from right)
		right = Lists.newArrayList(6, 2, 3, 1, 0, 4, 7);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(9));
		// Inserted just before "2"
		assertEquals(1, insertionIndex);

		// Merge the move of "0" (assume 0 already removed from right)
		right = Lists.newArrayList(6, 9, 2, 3, 1, 4, 7);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		// Inserted just before "4"
		assertEquals(5, insertionIndex);

		// merge the addition of "8"
		right = Lists.newArrayList(6, 9, 2, 3, 1, 0, 4, 7);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(8));
		// Inserted just before "9"
		assertEquals(1, insertionIndex);

		// remove "7"... right = {6, 8, 9, 2, 3, 1, 0, 4}

		// merge the move of "4" (assume already removed from right)
		right = Lists.newArrayList(6, 8, 9, 2, 3, 1, 0);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(4));
		// Inserted just after "3"
		assertEquals(5, insertionIndex);

		// merge the move of "6" (assume already removed from right)
		right = Lists.newArrayList(8, 9, 2, 3, 4, 1, 0);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(6));
		// Inserted just after "0"
		assertEquals(7, insertionIndex);
	}

	@Test
	public void insertionIndexTest2() {
		// Try and insert between two lists with no common element
		final List<Integer> right = Lists.newArrayList(4, 5, 6);
		final Comparison emptyComparison = createEmptyComparison();
		// We'll add "0" in right and expect it to be added at the end wherever its location in left
		final int expectedIndex = right.size();

		List<Integer> left = Lists.newArrayList(0, 1, 2, 3);
		int insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(1, 0, 2, 3);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(1, 2, 3, 0);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);
	}

	@Test
	public void insertionIndexTest3() {
		// Try and insert an element before the LCS, LCS being the whole second list
		final List<Integer> right = Lists.newArrayList(1, 2, 3);
		final Comparison emptyComparison = createEmptyComparison();
		// We'll add "0" in right and expect it to be added at the beginning
		final int expectedIndex = 0;

		List<Integer> left = Lists.newArrayList(0, 1, 2, 3);
		int insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(0, 4, 1, 2, 3);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(4, 0, 1, 2, 3);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(4, 0, 5, 1, 2, 3);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(4, 0, 5, 1, 2, 3, 6);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(4, 0, 5, 1, 6, 2, 3);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(4, 0, 5, 1, 6, 2, 7, 8, 3, 9);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);
	}

	@Test
	public void insertionIndexTest4() {
		// Try and insert an element before the LCS, LCS being part of the second list
		// We'll add "0" in right and expect it to be added just before the LCS
		final Comparison emptyComparison = createEmptyComparison();

		List<Integer> left = Lists.newArrayList(0, 1, 2, 3);
		List<Integer> right = Lists.newArrayList(4, 1, 2, 3);
		// Start of LCS is 1
		int expectedIndex = right.indexOf(Integer.valueOf(1));
		int insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(0, 6, 1, 5, 2, 4, 3);
		right = Lists.newArrayList(7, 4, 1, 2, 3, 8);
		// Start of LCS is 1
		expectedIndex = right.indexOf(Integer.valueOf(1));
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(5, 0, 6, 7, 1, 2, 4, 3);
		right = Lists.newArrayList(7, 4, 1, 2, 9, 3, 8);
		// Start of LCS is 7
		expectedIndex = right.indexOf(Integer.valueOf(7));
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);
	}

	@Test
	public void insertionIndexTest5() {
		// Try and insert an element after the LCS, LCS being the whole second list
		final List<Integer> right = Lists.newArrayList(1, 2, 3);
		final Comparison emptyComparison = createEmptyComparison();
		// We'll add "0" in right and expect it to be added at the end
		final int expectedIndex = right.size();

		List<Integer> left = Lists.newArrayList(1, 2, 3, 0);
		int insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(1, 2, 3, 4, 0);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(1, 2, 3, 0, 4);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(1, 2, 3, 5, 0, 4);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(6, 1, 2, 3, 5, 0, 4);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(1, 6, 2, 3, 5, 0, 4);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(9, 1, 6, 2, 7, 8, 3, 5, 0, 4);
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);
	}

	@Test
	public void insertionIndexTest6() {
		// Try and insert an element after the LCS, LCS being part of the second list
		// We'll add "0" in right and expect it to be added just after the LCS
		final Comparison emptyComparison = createEmptyComparison();

		List<Integer> left = Lists.newArrayList(1, 2, 3, 0);
		List<Integer> right = Lists.newArrayList(1, 2, 3, 4);
		// End of LCS is 3
		int expectedIndex = right.indexOf(Integer.valueOf(3)) + 1;
		int insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(1, 5, 2, 4, 3, 6, 0);
		right = Lists.newArrayList(8, 1, 2, 3, 4, 7);
		// End of LCS is 3
		expectedIndex = right.indexOf(Integer.valueOf(3)) + 1;
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(1, 2, 4, 3, 7, 6, 0, 5);
		right = Lists.newArrayList(8, 1, 2, 9, 3, 4, 7);
		// End of LCS is 7
		expectedIndex = right.indexOf(Integer.valueOf(7)) + 1;
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);
	}

	@Test
	public void insertionIndexTest7() {
		// Try and insert an element in the middle of the LCS, LCS being the whole second list
		// We'll add "0" in right and expect it to be added right after the closest LCS element
		final List<Integer> right = Lists.newArrayList(1, 2, 3);
		final Comparison emptyComparison = createEmptyComparison();

		List<Integer> left = Lists.newArrayList(1, 0, 2, 3);
		// Closest LCS element "before" is 1
		int expectedIndex = right.indexOf(Integer.valueOf(1)) + 1;
		int insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(1, 2, 0, 3, 4);
		// Closest LCS element "before" is 2
		expectedIndex = right.indexOf(Integer.valueOf(2)) + 1;
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(1, 0, 4, 2, 3);
		// Closest LCS element "before" is 1
		expectedIndex = right.indexOf(Integer.valueOf(1)) + 1;
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(5, 1, 4, 2, 0, 3);
		// Closest LCS element "before" is 2
		expectedIndex = right.indexOf(Integer.valueOf(2)) + 1;
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(6, 1, 7, 8, 0, 9, 2, 10, 3, 5, 4);
		// Closest LCS element "before" is 1
		expectedIndex = right.indexOf(Integer.valueOf(1)) + 1;
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);
	}

	@Test
	public void insertionIndexTest8() {
		// Try and insert an element in the middle of the LCS, LCS being part of the second list
		// We'll add "0" in right and expect it to be added right after the closest LCS element
		final Comparison emptyComparison = createEmptyComparison();

		List<Integer> left = Lists.newArrayList(1, 2, 0, 3);
		List<Integer> right = Lists.newArrayList(1, 2, 3, 4);
		// Closest LCS element is 2
		int expectedIndex = right.indexOf(Integer.valueOf(2)) + 1;
		int insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		left = Lists.newArrayList(1, 5, 2, 4, 0, 3, 6);
		right = Lists.newArrayList(8, 1, 2, 3, 4, 7);
		// Closest LCS element is 2
		expectedIndex = right.indexOf(Integer.valueOf(2)) + 1;
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);

		/*
		 * This is documented in {@link DefaultDiffEngine#findInsertionIndex(Comparison, List, List, Object)}.
		 * Ensure the documentation stays in sync.
		 */
		left = Lists.newArrayList(1, 2, 4, 6, 8, 3, 0, 7, 5);
		right = Lists.newArrayList(8, 1, 2, 9, 3, 4, 7);
		// Closest LCS element is 3
		expectedIndex = right.indexOf(Integer.valueOf(3)) + 1;
		insertionIndex = DiffUtil.findInsertionIndex(emptyComparison, left, right, Integer.valueOf(0));
		assertEquals(expectedIndex, insertionIndex);
	}

	/**
	 * Tests {@link NameSimilarity#nameSimilarityMetric(String, String)}.
	 * <p>
	 * Expected results :
	 * <table>
	 * <tr>
	 * <td>arg1</td>
	 * <td>arg2</td>
	 * <td>result</td>
	 * </tr>
	 * <tr>
	 * <td>"ceString"</td>
	 * <td>"ceString"</td>
	 * <td><code>1</code></td>
	 * </tr>
	 * <tr>
	 * <td>"classe"</td>
	 * <td>"Classe"</td>
	 * <td><code>0.8</code></td>
	 * </tr>
	 * <tr>
	 * <td>"Classe"</td>
	 * <td>"UneClasse"</td>
	 * <td><code>10/13</code></td>
	 * </tr>
	 * <tr>
	 * <td>"package"</td>
	 * <td>"packagedeux"</td>
	 * <td><code>12/16</code></td>
	 * </tr>
	 * <tr>
	 * <td>""</td>
	 * <td>"MaClasse"</td>
	 * <td><code>0</code></td>
	 * </tr>
	 * <tr>
	 * <td>"package"</td>
	 * <td>"packageASupprimer"</td>
	 * <td><code>12/22</code></td>
	 * </tr>
	 * <tr>
	 * <td>"attribut"</td>
	 * <td>"reference"</td>
	 * <td><code>0</code></td>
	 * </tr>
	 * <tr>
	 * <td>"aa"</td>
	 * <td>"aaaa"</td>
	 * <td><code>1/3</code></td>
	 * </tr>
	 * <tr>
	 * <td>"v1"</td>
	 * <td>"v2"</td>
	 * <td><code>2/4</code></td>
	 * </tr>
	 * <tr>
	 * <td>"v"</td>
	 * <td>"v1"</td>
	 * <td><code>1/3</code></td>
	 * </tr>
	 * <tr>
	 * <td>"a"</td>
	 * <td>"a"</td>
	 * <td><code>1</code></td>
	 * </tr>
	 * <tr>
	 * <td>"a"</td>
	 * <td>"b"</td>
	 * <td><code>0</code></td>
	 * </tr>
	 * <tr>
	 * <td>"a"</td>
	 * <td>"A"</td>
	 * <td><code>0</code></td>
	 * </tr>
	 * </table>
	 * </p>
	 */
	@Test
	public void diceCoefficient() {
		final String[] data = new String[] {"ceString", "ceString", "classe", "Classe", "Classe", "UneClasse",
				"package", "packagedeux", "", "MaClasse", "package", "packageASupprimer", "attribut",
				"reference", "aa", "aaaa", "aaa", "aaaa", "v1", "v2", "v", "v1", "a", "a", "a", "b", "a", "A",
				"GGG", "GGGGGG", "night", "nacht", };
		final double[] similarities = new double[] {1d, 0.8d, 10d / 13d, 12d / 16d, 0d, 12d / 22d, 0d,
				2d / 4d, 4d / 5d, 1d / 2d, 1d / 3d, 1d, 0d, 0d, 4d / 7d, 2d / 8d };
		for (int i = 0; i < data.length; i += 2) {
			assertEquals(
					"Unexpected result of the dice coefficient for str1 = " + data[i] + " and str2 = "
							+ data[i + 1],
					similarities[i / 2], DiffUtil.diceCoefficient(data[i], data[i + 1]), Double.MIN_VALUE);
			// Make sure that the result is symmetric
			assertEquals(
					"Dice coefficient was not symmetric for str1 = " + data[i] + " and str2 = " + data[i + 1],
					similarities[i / 2], DiffUtil.diceCoefficient(data[i + 1], data[i]), Double.MIN_VALUE);
		}
	}

	@Test
	public void diceCoefficientInvariants() {
		final double sVV1 = DiffUtil.diceCoefficient("v", "v1");
		final double sVV11 = DiffUtil.diceCoefficient("v", "v11");
		final double sVV111 = DiffUtil.diceCoefficient("v", "v111");
		assertTrue(sVV1 > sVV11 && sVV11 > sVV111);

		final double sV1V2 = DiffUtil.diceCoefficient("v1", "v2");
		final double sVV2 = DiffUtil.diceCoefficient("v", "v2");
		assertTrue(sV1V2 > sVV2);

		final double sV1V11 = DiffUtil.diceCoefficient("v1", "v11");
		assertTrue(sV1V11 > sVV11 && sV1V2 > sVV11);
	}

	@Test
	public void diceCoefficient_444712() {
		final double sT11T11 = DiffUtil.diceCoefficient("thing 11", "thing 11");
		final double sT11T111 = DiffUtil.diceCoefficient("thing 11", "thing 111");
		assertTrue(sT11T11 > sT11T111);

		// kinda redundant... check anyway for potential "strange" values
		assertTrue(sT11T11 <= 1d);
		assertTrue(sT11T111 < 1d);
	}

	@Test
	public void diceCoefficientSameBigramsDifferentStrings() {
		final double identical = DiffUtil.diceCoefficient("pierre pascale", "pierre pascale");
		final double distinctButSameBigrams = DiffUtil.diceCoefficient("pierre pascale", "pascale pierre");
		assertTrue(identical > distinctButSameBigrams);
		assertTrue(distinctButSameBigrams < 1d);
		assertTrue(distinctButSameBigrams > 0.95d);
	}

	@Test
	public void diceCoefficientFullWidth() {
		final String[] data = new String[] {"ｃｅＳｔｒｉｎｇ", "ｃｅＳｔｒｉｎｇ", "ｃｌａｓｓｅ", "Ｃｌａｓｓｅ", "Ｃｌａｓｓｅ", "ＵｎｅＣｌａｓｓｅ",
				"ｐａｃｋａｇｅ", "ｐａｃｋａｇｅｄｅｕｘ", "", "ＭａＣｌａｓｓｅ", "ｐａｃｋａｇｅ", "ｐａｃｋａｇｅＡＳｕｐｐｒｉｍｅｒ", "ａｔｔｒｉｂｕｔ",
				"ｒｅｆｅｒｅｎｃｅ", "ａａ", "ａａａａ", "ａａａ", "ａａａａ", "ｖ１", "ｖ２", "ｖ", "ｖ１", "ａ", "ａ", "ａ", "ｂ", "ａ", "Ａ",
				"ＧＧＧ", "ＧＧＧＧＧＧ", "ｎｉｇｈｔ", "ｎａｃｈｔ", "ｆｕｌｌｗｉｄｔｈ  ｓｔｒｉｎｇ", "ｆｕｌｌｗｉｄｔｈ  ｓｔｒｉｎｇ",
				"ｆｕｌｌｗｉｄｔｈ  ｓｔｒｉｎｇ", "fｕｌｌｗｉｄｔｈ  ＣｈａｒＳｅｑｕｅｎｃｅ" };
		final double[] similarities = new double[] {1d, 0.8d, 10d / 13d, 12d / 16d, 0d, 12d / 22d, 0d,
				2d / 4d, 4d / 5d, 1d / 2d, 1d / 3d, 1d, 0d, 0d, 4d / 7d, 2d / 8d, 1d, 18d / 38d, };

		for (int i = 0; i < data.length; i += 2) {
			assertEquals(
					"Unexpected result of the dice coefficient for str1 = " + data[i] + " and str2 = "
							+ data[i + 1],
					similarities[i / 2], DiffUtil.diceCoefficient(data[i], data[i + 1]), Double.MIN_VALUE);
			// Make sure that the result is symmetric
			assertEquals(
					"Dice coefficient was not symmetric for str1 = " + data[i] + " and str2 = " + data[i + 1],
					similarities[i / 2], DiffUtil.diceCoefficient(data[i + 1], data[i]), Double.MIN_VALUE);
		}
	}

	@Test
	public void diceCoefficientFailure() {
		try {
			DiffUtil.diceCoefficient(null, null);
			fail("Expected exception has not been thrown");
		} catch (NullPointerException e) {
			// expected
		}
		try {
			DiffUtil.diceCoefficient(null, "aString");
			fail("Expected exception has not been thrown");
		} catch (NullPointerException e) {
			// expected
		}
		try {
			DiffUtil.diceCoefficient("aString", null);
			fail("Expected exception has not been thrown");
		} catch (NullPointerException e) {
			// expected
		}
	}

	/**
	 * Ensures that the two given lists contain the same elements in the same order. The kind of list does not
	 * matter.
	 * 
	 * @param list1
	 *            First of the two lists to compare.
	 * @param list2
	 *            Second of the two lists to compare.
	 */
	private static <T> void assertEqualContents(List<T> list1, List<T> list2) {
		final int size = list1.size();
		assertEquals(size, list2.size());

		for (int i = 0; i < size; i++) {
			assertEquals(list1.get(i), list2.get(i));
		}
	}

	/**
	 * Creates and return a new empty {@link Comparison} object with a defaut {@link EMFCompareConfiguration}.
	 * 
	 * @return the created {@link Comparison}.
	 */
	private static Comparison createEmptyComparison() {
		final Comparison emptyComparison = CompareFactory.eINSTANCE.createComparison();
		return emptyComparison;
	}
}