EMFComparePredicatesTest.java

/*******************************************************************************
 * Copyright (c) 2016 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.utils;

import static com.google.common.base.Predicates.equalTo;
import static com.google.common.base.Predicates.instanceOf;
import static java.util.Arrays.asList;
import static org.eclipse.emf.compare.ConflictKind.PSEUDO;
import static org.eclipse.emf.compare.ConflictKind.REAL;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.allAtomicRefining;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.anyRefining;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.hasDirectOrIndirectConflict;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.hasNoDirectOrIndirectConflict;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.compare.AttributeChange;
import org.eclipse.emf.compare.CompareFactory;
import org.eclipse.emf.compare.Comparison;
import org.eclipse.emf.compare.Conflict;
import org.eclipse.emf.compare.Diff;
import org.eclipse.emf.compare.Match;
import org.eclipse.emf.compare.ReferenceChange;
import org.junit.Test;

public class EMFComparePredicatesTest {

	private CompareFactory factory = CompareFactory.eINSTANCE;

	@Test
	public void testAnyRefiningWithoutRecursion() {
		Comparison comp = factory.createComparison();
		Match rootMatch = factory.createMatch();
		comp.getMatches().add(rootMatch);

		AttributeChange ac = factory.createAttributeChange();
		ReferenceChange rc1 = factory.createReferenceChange();
		ReferenceChange rc2 = factory.createReferenceChange();
		ReferenceChange rc3 = factory.createReferenceChange();
		EList<Diff> diffs = rootMatch.getDifferences();
		diffs.add(ac);
		diffs.add(rc1);
		diffs.add(rc2);
		diffs.add(rc3);
		ac.getRefinedBy().addAll(asList(rc1, rc2, rc3));

		assertFalse(anyRefining(instanceOf(AttributeChange.class)).apply(ac));
		assertTrue(anyRefining(instanceOf(ReferenceChange.class)).apply(ac));
		assertTrue(anyRefining(equalTo((Diff)rc3)).apply(ac));
	}

	@Test
	public void testAnyRefiningWithRecursion() {
		Comparison comp = factory.createComparison();
		Match rootMatch = factory.createMatch();
		comp.getMatches().add(rootMatch);

		AttributeChange ac = factory.createAttributeChange();
		AttributeChange ac1 = factory.createAttributeChange();
		ReferenceChange rc11 = factory.createReferenceChange();
		ReferenceChange rc12 = factory.createReferenceChange();
		ReferenceChange rc2 = factory.createReferenceChange();
		ReferenceChange rc3 = factory.createReferenceChange();
		EList<Diff> diffs = rootMatch.getDifferences();
		diffs.add(ac);
		diffs.add(ac1);
		diffs.add(rc11);
		diffs.add(rc12);
		diffs.add(rc2);
		diffs.add(rc3);
		ac.getRefinedBy().addAll(asList(ac1, rc2, rc3));
		ac1.getRefinedBy().addAll(asList(rc11, rc12));

		assertTrue(anyRefining(instanceOf(AttributeChange.class)).apply(ac));
		assertTrue(anyRefining(instanceOf(ReferenceChange.class)).apply(ac));
		assertTrue(anyRefining(equalTo((Diff)rc12)).apply(ac));
		assertFalse(anyRefining(equalTo((Diff)ac)).apply(ac));
	}

	@Test
	public void testAllAtomicRefiningWithoutRecursion() {
		Comparison comp = factory.createComparison();
		Match rootMatch = factory.createMatch();
		comp.getMatches().add(rootMatch);

		AttributeChange ac = factory.createAttributeChange();
		ReferenceChange rc1 = factory.createReferenceChange();
		ReferenceChange rc2 = factory.createReferenceChange();
		ReferenceChange rc3 = factory.createReferenceChange();
		EList<Diff> diffs = rootMatch.getDifferences();
		diffs.add(ac);
		diffs.add(rc1);
		diffs.add(rc2);
		diffs.add(rc3);
		ac.getRefinedBy().addAll(asList(rc1, rc2, rc3));

		assertFalse(allAtomicRefining(instanceOf(AttributeChange.class)).apply(ac));
		assertTrue(allAtomicRefining(instanceOf(ReferenceChange.class)).apply(ac));
		assertFalse(allAtomicRefining(equalTo((Diff)rc3)).apply(ac));
	}

	@Test
	public void testAllAtomicRefiningWithRecursion() {
		Comparison comp = factory.createComparison();
		Match rootMatch = factory.createMatch();
		comp.getMatches().add(rootMatch);

		AttributeChange ac = factory.createAttributeChange();
		AttributeChange ac1 = factory.createAttributeChange();
		ReferenceChange rc11 = factory.createReferenceChange();
		ReferenceChange rc12 = factory.createReferenceChange();
		ReferenceChange rc2 = factory.createReferenceChange();
		ReferenceChange rc3 = factory.createReferenceChange();
		EList<Diff> diffs = rootMatch.getDifferences();
		diffs.add(ac);
		diffs.add(ac1);
		diffs.add(rc11);
		diffs.add(rc12);
		diffs.add(rc2);
		diffs.add(rc3);
		ac.getRefinedBy().addAll(asList(ac1, rc2, rc3));
		ac1.getRefinedBy().addAll(asList(rc11, rc12));

		assertFalse(allAtomicRefining(instanceOf(AttributeChange.class)).apply(ac));
		assertTrue(allAtomicRefining(instanceOf(ReferenceChange.class)).apply(ac));
		assertFalse(allAtomicRefining(equalTo((Diff)rc12)).apply(ac));
	}

	@Test
	public void testHasDirectOrIndirectConflictForDirectConflict() {
		Comparison comp = factory.createComparison();
		Match rootMatch = factory.createMatch();
		comp.getMatches().add(rootMatch);
		AttributeChange acl = factory.createAttributeChange();
		AttributeChange acr = factory.createAttributeChange();
		rootMatch.getDifferences().addAll(asList(acl, acr));
		Conflict conflict = factory.createConflict();
		conflict.setKind(REAL);
		conflict.getDifferences().addAll(asList(acl, acr));
		comp.getConflicts().add(conflict);

		assertTrue(hasDirectOrIndirectConflict(REAL).apply(acl));
		assertTrue(hasDirectOrIndirectConflict(REAL).apply(acr));
		assertFalse(hasDirectOrIndirectConflict(PSEUDO).apply(acl));
		assertFalse(hasDirectOrIndirectConflict(PSEUDO).apply(acr));

		assertFalse(hasNoDirectOrIndirectConflict(REAL).apply(acl));
		assertFalse(hasNoDirectOrIndirectConflict(REAL).apply(acr));
		assertTrue(hasNoDirectOrIndirectConflict(PSEUDO).apply(acl));
		assertTrue(hasNoDirectOrIndirectConflict(PSEUDO).apply(acr));
	}

	@Test
	public void testHasDirectOrIndirectConflictForIndirectConflict() {
		Comparison comp = factory.createComparison();
		Match rootMatch = factory.createMatch();
		comp.getMatches().add(rootMatch);
		ReferenceChange rc = factory.createReferenceChange();
		AttributeChange acl = factory.createAttributeChange();
		AttributeChange acr = factory.createAttributeChange();
		rootMatch.getDifferences().addAll(asList(rc, acl, acr));
		rc.getRefinedBy().addAll(asList(acl));
		Conflict conflict = factory.createConflict();
		conflict.setKind(REAL);
		conflict.getDifferences().addAll(asList(acl, acr));
		comp.getConflicts().add(conflict);

		assertTrue(hasDirectOrIndirectConflict(REAL).apply(rc));
		assertFalse(hasDirectOrIndirectConflict(PSEUDO).apply(rc));
		assertFalse(hasNoDirectOrIndirectConflict(REAL).apply(rc));
		assertTrue(hasNoDirectOrIndirectConflict(PSEUDO).apply(rc));
	}
}