plugins/cdo/org.eclipse.papyrus.cdo.validation.problems.tests/src/org/eclipse/papyrus/cdo/validation/problems/util/tests/ProblemsManagerTest.java - papyrus/org.eclipse.papyrus-collaborativemodeling - Git at Google

 /*****************************************************************************
  * Copyright (c) 2013, 2017 CEA LIST, Christian W. Damus, 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:
  *   CEA LIST - Initial API and implementation
  *   Christian W. Damus - bug 460716
  *****************************************************************************/
 package org.eclipse.papyrus.cdo.validation.problems.util.tests;

 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.CoreMatchers.sameInstance;
 import static org.junit.Assert.assertThat;

 import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 import java.util.regex.Pattern;

 import org.eclipse.emf.cdo.eresource.CDOResource;
 import org.eclipse.emf.cdo.transaction.CDOTransaction;
 import org.eclipse.emf.cdo.view.CDOView;
 import org.eclipse.emf.common.util.BasicDiagnostic;
 import org.eclipse.emf.common.util.Diagnostic;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EValidator;
 import org.eclipse.emf.ecore.impl.EValidatorRegistryImpl;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.ecore.util.Diagnostician;
 import org.eclipse.emf.ecore.util.ECrossReferenceAdapter;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.papyrus.cdo.core.tests.AbstractPapyrusCDOTest;
 import org.eclipse.papyrus.cdo.validation.problems.EProblem;
 import org.eclipse.papyrus.cdo.validation.problems.ESeverity;
 import org.eclipse.papyrus.cdo.validation.problems.ProblemsPackage;
 import org.eclipse.papyrus.cdo.validation.problems.util.ProblemsManager;
 import org.eclipse.uml2.uml.Class;
 import org.eclipse.uml2.uml.Interface;
 import org.eclipse.uml2.uml.Model;
 import org.eclipse.uml2.uml.UMLFactory;
 import org.eclipse.uml2.uml.UMLPackage;
 import org.eclipse.uml2.uml.resource.UMLResource;
 import org.eclipse.uml2.uml.util.UMLValidator;
 import org.junit.After;
 import org.junit.Test;

 import com.google.common.base.Function;
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;

 /**
  * Tests suite for the {@link ProblemsManager} API.
  */
 public class ProblemsManagerTest
 		extends AbstractPapyrusCDOTest {

 	private Set<ProblemsManager> managers = new java.util.HashSet<ProblemsManager>();

 	@Test
 	public void getProblemsAdapter() {
 		CDOTransaction transaction = createTransaction();

 		ProblemsManager mgr = getProblemsManager(transaction);

 		// doesn't create a new instance
 		assertThat(mgr,
 				sameInstance(ProblemsManager.getProblemsManager(transaction
 						.getResourceSet())));
 	}

 	@Test
 	public void allProblems() {
 		CDOTransaction transaction = createTransaction();
 		CDOResource resource = transaction
 				.createResource(getResourcePath("/resource1"));

 		createTestModel(resource);
 		final int expectedProblems = computeExpectedProblemsCount();

 		ProblemsManager mgr = getProblemsManager(transaction);
 		mgr.addDiagnostic(validate(resource));

 		Collection<EProblem> allProblems = collect(mgr.getAllProblems());
 		assertThat(allProblems.size(), equalTo(expectedProblems));
 		assertIndistinguishableMembersProblem(resource, allProblems);
 		assertGeneralCompatibilityProblem(resource, allProblems);
 		assertUnownedElementProblem(resource, allProblems);
 	}

 	@Test
 	public void allProblems_EObject_noCrossReferencer() {
 		CDOTransaction transaction = createTransaction();
 		CDOResource resource = transaction
 				.createResource(getResourcePath("/resource1"));

 		createTestModel(resource);
 		final int expectedProblems = computeExpectedProblemsCount(getClass2());

 		ProblemsManager mgr = getProblemsManager(transaction);
 		mgr.addDiagnostic(validate(resource));

 		Collection<EProblem> problems = collect(mgr
 				.getAllProblems(getClass2(resource)));
 		assertThat(problems.size(), equalTo(expectedProblems));
 		assertIndistinguishableMembersProblem(resource, problems);
 		assertGeneralCompatibilityProblem(resource, problems);
 	}

 	@Test
 	public void allProblems_EObject_crossReferencer() {
 		CDOTransaction transaction = createTransaction();
 		CDOResource resource = transaction
 				.createResource(getResourcePath("/resource1"));

 		// attach a cross-reference adapter
 		transaction.getResourceSet().eAdapters()
 				.add(new ECrossReferenceAdapter());

 		createTestModel(resource);
 		final int expectedProblems = computeExpectedProblemsCount(getClass2());

 		ProblemsManager mgr = getProblemsManager(transaction);
 		mgr.addDiagnostic(validate(resource));

 		Collection<EProblem> problems = collect(mgr
 				.getAllProblems(getClass2(resource)));
 		assertThat(problems.size(), equalTo(expectedProblems));
 		assertIndistinguishableMembersProblem(resource, problems);
 		assertGeneralCompatibilityProblem(resource, problems);
 	}

 	@Test
 	public void purgeAll_noCrossReferencer() {
 		CDOTransaction transaction = createTransaction();
 		CDOResource resource = transaction
 				.createResource(getResourcePath("/resource1"));

 		createTestModel(resource);

 		ProblemsManager mgr = getProblemsManager(transaction);
 		mgr.addDiagnostic(validate(resource));

 		mgr.purgeAllProblems();

 		assertThat(mgr.getAllProblems().hasNext(), is(false));
 	}

 	@Test
 	public void purgeAll_crossReferencer() {
 		CDOTransaction transaction = createTransaction();
 		CDOResource resource = transaction
 				.createResource(getResourcePath("/resource1"));

 		// attach a cross-reference adapter
 		transaction.getResourceSet().eAdapters()
 				.add(new ECrossReferenceAdapter());

 		createTestModel(resource);

 		ProblemsManager mgr = getProblemsManager(transaction);
 		mgr.addDiagnostic(validate(resource));

 		mgr.purgeAllProblems();

 		assertThat(mgr.getAllProblems().hasNext(), is(false));
 	}

 	@Test
 	public void purge_noCrossReferencer() {
 		CDOTransaction transaction = createTransaction();
 		CDOResource resource = transaction
 				.createResource(getResourcePath("/resource1"));

 		createTestModel(resource);
 		final int expectedTotalProblems = computeExpectedProblemsCount();
 		final int expectedClass3Problems = computeExpectedProblemsCount(getClass3());

 		ProblemsManager mgr = getProblemsManager(transaction);
 		mgr.addDiagnostic(validate(resource));

 		mgr.purgeProblems(getClass3(resource));

 		Collection<EProblem> problems = collect(mgr.getAllProblems());
 		assertThat(problems.size(), equalTo(expectedTotalProblems - expectedClass3Problems));
 		assertIndistinguishableMembersProblem(resource, problems);
 		assertGeneralCompatibilityProblem(resource, problems);
 	}

 	@Test
 	public void purge_crossReferencer() {
 		CDOTransaction transaction = createTransaction();
 		CDOResource resource = transaction
 				.createResource(getResourcePath("/resource1"));

 		// attach a cross-reference adapter
 		transaction.getResourceSet().eAdapters()
 				.add(new ECrossReferenceAdapter());

 		createTestModel(resource);
 		final int expectedTotalProblems = computeExpectedProblemsCount();
 		final int expectedClass3Problems = computeExpectedProblemsCount(getClass3());

 		ProblemsManager mgr = getProblemsManager(transaction);
 		mgr.addDiagnostic(validate(resource));

 		mgr.purgeProblems(getClass3(resource));

 		Collection<EProblem> problems = collect(mgr.getAllProblems());
 		assertThat(problems.size(), equalTo(expectedTotalProblems - expectedClass3Problems));
 		assertIndistinguishableMembersProblem(resource, problems);
 		assertGeneralCompatibilityProblem(resource, problems);
 	}

 	@Test
 	public void disposeProblemsManager()
 			throws Exception {

 		CDOTransaction transaction = createTransaction();
 		CDOResource resource = transaction
 				.createResource(getResourcePath("/resource1"));

 		// attach a cross-reference adapter
 		ECrossReferenceAdapter xrefs = new ECrossReferenceAdapter();
 		transaction.getResourceSet().eAdapters().add(xrefs);

 		createTestModel(resource);

 		ProblemsManager mgr = getProblemsManager(transaction);
 		mgr.addDiagnostic(validate(resource));

 		// gather weak references to the problems
 		ReferenceQueue<EProblem> queue = new ReferenceQueue<EProblem>();
 		List<Reference<EProblem>> references = new java.util.ArrayList<Reference<EProblem>>(
 				3);
 		for (Iterator<EProblem> iter = mgr.getAllProblems(); iter.hasNext();) {
 			references.add(new WeakReference<EProblem>(iter.next(), queue));
 		}

 		mgr.dispose();

 		// try to force GC
 		for (int i = 0; i < 10; i++) {
 			System.gc();
 		}

 		// assert that the problems are unreachable
 		for (int i = 0; i < 3; i++) {
 			Reference<? extends EProblem> ref = queue.remove(1000);
 			assertThat(ref, notNullValue());
 		}
 	}

 	@Test
 	public void dispose_crossReferencerAddedAfter()
 			throws Exception {

 		CDOTransaction transaction = createTransaction();
 		CDOResource resource = transaction
 				.createResource(getResourcePath("/resource1"));

 		createTestModel(resource);

 		ProblemsManager mgr = getProblemsManager(transaction);
 		mgr.addDiagnostic(validate(resource));

 		// attach a cross-reference adapter *after* adding problems
 		ECrossReferenceAdapter xrefs = new ECrossReferenceAdapter();
 		transaction.getResourceSet().eAdapters().add(xrefs);

 		// gather weak references to the problems
 		ReferenceQueue<EProblem> queue = new ReferenceQueue<EProblem>();
 		List<Reference<EProblem>> references = new java.util.ArrayList<Reference<EProblem>>(
 				3);
 		for (Iterator<EProblem> iter = mgr.getAllProblems(); iter.hasNext();) {
 			references.add(new WeakReference<EProblem>(iter.next(), queue));
 		}

 		mgr.dispose();

 		// try to force GC
 		for (int i = 0; i < 10; i++) {
 			System.gc();
 		}

 		// assert that the problems are unreachable
 		for (int i = 0; i < 3; i++) {
 			Reference<? extends EProblem> ref = queue.remove(1000);
 			assertThat(ref, notNullValue());
 		}
 	}

 	@Test
 	public void customProblemClass() {
 		CDOTransaction transaction = createTransaction();
 		CDOResource resource = transaction
 				.createResource(getResourcePath("/resource1"));

 		createTestModel(resource);
 		final int expectedProblems = computeExpectedProblemsCount();

 		// not actually a different class, but a different way of creating it
 		ProblemsManager mgr = ProblemsManager.createProblemsManager(
 				transaction.getResourceSet(), ProblemsPackage.Literals.EPROBLEM);
 		managers.add(mgr);
 		mgr.addDiagnostic(validate(resource));

 		Collection<EProblem> allProblems = collect(mgr.getAllProblems());
 		assertThat(allProblems.size(), equalTo(expectedProblems));
 		assertIndistinguishableMembersProblem(resource, allProblems);
 		assertGeneralCompatibilityProblem(resource, allProblems);
 		assertUnownedElementProblem(resource, allProblems);
 	}

 	//
 	// Test framework
 	//

 	@After
 	public void disposeProblemManagers()
 			throws Exception {

 		for (ProblemsManager next : managers) {
 			next.dispose();
 		}
 	}

 	void createTestModel(Resource res) {
 		Model model = UMLFactory.eINSTANCE.createModel();
 		model.setName("testmodel");
 		res.getContents().add(model);

 		Class class1 = model.createOwnedClass("Class1", false);

 		Interface interface1 = model.createOwnedInterface("Interface1");

 		Class class2 = model.createOwnedClass("Class2", false);
 		class2.createGeneralization(interface1); // invalid generalization
 		class2.createOwnedAttribute("attr1", class1);
 		class2.createOwnedAttribute("attr1", class1); // indistinguishable

 		Class class3 = UMLFactory.eINSTANCE.createClass();
 		class3.setName("Class3");
 		res.getContents().add(class3); // not owned
 	}

 	int computeExpectedProblemsCount() {
 		int result;

 		Resource resource = createScratchResource();

 		try {
 			Diagnostic diagnostic = validate(resource);
 			result = diagnostic.getChildren().size();
 		} finally {
 			unload(resource);
 		}

 		return result;
 	}

 	int computeExpectedProblemsCount(Function<Resource, ? extends EObject> pertainingTo) {
 		int result;

 		Resource resource = createScratchResource();
 		final EObject target = pertainingTo.apply(resource);

 		try {
 			Diagnostic diagnostic = validate(resource);
 			result = Iterables.size(Iterables.filter(diagnostic.getChildren(), new Predicate<Diagnostic>() {
 				@Override
 				public boolean apply(Diagnostic input) {
 					List<?> data = input.getData();
 					return (data != null) && !data.isEmpty() && (data.get(0) == target);
 				}
 			}));
 		} finally {
 			unload(resource);
 		}

 		return result;
 	}

 	Resource createScratchResource() {
 		Resource result = UMLResource.Factory.INSTANCE.createResource(URI.createURI("bogus://scratch.uml"));
 		createTestModel(result);
 		return result;
 	}

 	void unload(Resource resource) {
 		resource.unload();
 		if (resource.getResourceSet() != null) {
 			resource.getResourceSet().getResources().remove(resource);
 		}
 		resource.eAdapters().clear();
 	}

 	Model getModel(Resource resource) {
 		return (Model) EcoreUtil.getObjectByType(resource.getContents(),
 				UMLPackage.Literals.MODEL);
 	}

 	Class getClass1(Resource resource) {
 		return getClass1().apply(resource);
 	}

 	Function<Resource, Class> getClass1() {
 		return getNamedClass("Class1");
 	}

 	Function<Resource, Class> getNamedClass(final String name) {
 		return new Function<Resource, Class>() {
 			@Override
 			public Class apply(Resource input) {
 				return (Class) getModel(input).getOwnedType(name);
 			}
 		};
 	}

 	Class getClass2(Resource resource) {
 		return getClass2().apply(resource);
 	}

 	Function<Resource, Class> getClass2() {
 		return getNamedClass("Class2");
 	}

 	Class getClass3(Resource resource) {
 		return getClass3().apply(resource);
 	}

 	Function<Resource, Class> getClass3() {
 		return getRoot(Class.class);
 	}

 	<T extends EObject> Function<Resource, T> getRoot(final java.lang.Class<T> metaclass) {
 		return new Function<Resource, T>() {
 			@Override
 			public T apply(Resource input) {
 				return Iterables.getFirst(Iterables.filter(input.getContents(), metaclass), null);
 			}
 		};
 	}

 	Interface getInterface1(Resource resource) {
 		return (Interface) getModel(resource).getOwnedType("Interface1");
 	}

 	ProblemsManager getProblemsManager(CDOView view) {
 		return getProblemsManager(view.getResourceSet());
 	}

 	ProblemsManager getProblemsManager(ResourceSet resourceSet) {
 		ProblemsManager result = ProblemsManager
 				.getProblemsManager(resourceSet);
 		managers.add(result);
 		return result;
 	}

 	Diagnostic validate(Resource resource) {
 		EValidator.Registry registry = new EValidatorRegistryImpl(
 				EValidator.Registry.INSTANCE);
 		registry.put(UMLPackage.eINSTANCE, new UMLValidator());

 		BasicDiagnostic result = new BasicDiagnostic();
 		Diagnostician diagnostician = new Diagnostician(registry);

 		for (EObject next : resource.getContents()) {
 			diagnostician.validate(next, result);
 		}

 		return result;
 	}

 	Collection<EProblem> collect(Iterator<? extends EProblem> problems) {
 		Collection<EProblem> result = new java.util.ArrayList<EProblem>();

 		while (problems.hasNext()) {
 			result.add(problems.next());
 		}

 		return result;
 	}

 	void assertProblem(Collection<EProblem> problems, ESeverity severity,
 			String source, int code, String messagePattern, EObject element,
 			EObject... related) {

 		final List<EObject> relatedList = Arrays.asList(related);
 		final Pattern pattern = Pattern.compile(messagePattern);

 		EProblem found = null;
 		for (EProblem problem : problems) {
 			if (problem.getElement() == element //
 					&& problem.getRelated().equals(relatedList) //
 					&& problem.getSeverity() == severity //
 					&& pattern.matcher(problem.getMessage()).find() //
 					&& source.equals(problem.getSource()) //
 					&& problem.getCode() == code) {
 				found = problem;
 				break;
 			}
 		}

 		assertThat(found, notNullValue());
 	}

 	void assertIndistinguishableMembersProblem(Resource resource,
 			Collection<EProblem> problems) {

 		Class class2 = getClass2(resource);

 		assertProblem(problems, ESeverity.WARNING,
 				UMLValidator.DIAGNOSTIC_SOURCE,
 				UMLValidator.NAMESPACE__MEMBERS_DISTINGUISHABLE, "disting", class2);
 	}

 	void assertGeneralCompatibilityProblem(Resource resource,
 			Collection<EProblem> problems) {

 		Class class2 = getClass2(resource);
 		Interface interface1 = getInterface1(resource);

 		assertProblem(problems, ESeverity.WARNING,
 				UMLValidator.DIAGNOSTIC_SOURCE,
 				UMLValidator.CLASSIFIER__SPECIALIZE_TYPE, "special", class2,
 				interface1);
 	}

 	void assertUnownedElementProblem(Resource resource,
 			Collection<EProblem> problems) {

 		Class class3 = getClass3(resource);

 		assertProblem(problems, ESeverity.WARNING,
 				UMLValidator.DIAGNOSTIC_SOURCE, UMLValidator.ELEMENT__HAS_OWNER,
 				"owned", class3);
 	}
 }
	/*****************************************************************************
	* Copyright (c) 2013, 2017 CEA LIST, Christian W. Damus, 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:
	* CEA LIST - Initial API and implementation
	* Christian W. Damus - bug 460716
	*****************************************************************************/
	package org.eclipse.papyrus.cdo.validation.problems.util.tests;

	import static org.hamcrest.CoreMatchers.equalTo;
	import static org.hamcrest.CoreMatchers.is;
	import static org.hamcrest.CoreMatchers.notNullValue;
	import static org.hamcrest.CoreMatchers.sameInstance;
	import static org.junit.Assert.assertThat;

	import java.lang.ref.Reference;
	import java.lang.ref.ReferenceQueue;
	import java.lang.ref.WeakReference;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Set;
	import java.util.regex.Pattern;

	import org.eclipse.emf.cdo.eresource.CDOResource;
	import org.eclipse.emf.cdo.transaction.CDOTransaction;
	import org.eclipse.emf.cdo.view.CDOView;
	import org.eclipse.emf.common.util.BasicDiagnostic;
	import org.eclipse.emf.common.util.Diagnostic;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.EValidator;
	import org.eclipse.emf.ecore.impl.EValidatorRegistryImpl;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.ecore.resource.ResourceSet;
	import org.eclipse.emf.ecore.util.Diagnostician;
	import org.eclipse.emf.ecore.util.ECrossReferenceAdapter;
	import org.eclipse.emf.ecore.util.EcoreUtil;
	import org.eclipse.papyrus.cdo.core.tests.AbstractPapyrusCDOTest;
	import org.eclipse.papyrus.cdo.validation.problems.EProblem;
	import org.eclipse.papyrus.cdo.validation.problems.ESeverity;
	import org.eclipse.papyrus.cdo.validation.problems.ProblemsPackage;
	import org.eclipse.papyrus.cdo.validation.problems.util.ProblemsManager;
	import org.eclipse.uml2.uml.Class;
	import org.eclipse.uml2.uml.Interface;
	import org.eclipse.uml2.uml.Model;
	import org.eclipse.uml2.uml.UMLFactory;
	import org.eclipse.uml2.uml.UMLPackage;
	import org.eclipse.uml2.uml.resource.UMLResource;
	import org.eclipse.uml2.uml.util.UMLValidator;
	import org.junit.After;
	import org.junit.Test;

	import com.google.common.base.Function;
	import com.google.common.base.Predicate;
	import com.google.common.collect.Iterables;

	/**
	* Tests suite for the {@link ProblemsManager} API.
	*/
	public class ProblemsManagerTest
	extends AbstractPapyrusCDOTest {

	private Set<ProblemsManager> managers = new java.util.HashSet<ProblemsManager>();

	@Test
	public void getProblemsAdapter() {
	CDOTransaction transaction = createTransaction();

	ProblemsManager mgr = getProblemsManager(transaction);

	// doesn't create a new instance
	assertThat(mgr,
	sameInstance(ProblemsManager.getProblemsManager(transaction
	.getResourceSet())));
	}

	@Test
	public void allProblems() {
	CDOTransaction transaction = createTransaction();
	CDOResource resource = transaction
	.createResource(getResourcePath("/resource1"));

	createTestModel(resource);
	final int expectedProblems = computeExpectedProblemsCount();

	ProblemsManager mgr = getProblemsManager(transaction);
	mgr.addDiagnostic(validate(resource));

	Collection<EProblem> allProblems = collect(mgr.getAllProblems());
	assertThat(allProblems.size(), equalTo(expectedProblems));
	assertIndistinguishableMembersProblem(resource, allProblems);
	assertGeneralCompatibilityProblem(resource, allProblems);
	assertUnownedElementProblem(resource, allProblems);
	}

	@Test
	public void allProblems_EObject_noCrossReferencer() {
	CDOTransaction transaction = createTransaction();
	CDOResource resource = transaction
	.createResource(getResourcePath("/resource1"));

	createTestModel(resource);
	final int expectedProblems = computeExpectedProblemsCount(getClass2());

	ProblemsManager mgr = getProblemsManager(transaction);
	mgr.addDiagnostic(validate(resource));

	Collection<EProblem> problems = collect(mgr
	.getAllProblems(getClass2(resource)));
	assertThat(problems.size(), equalTo(expectedProblems));
	assertIndistinguishableMembersProblem(resource, problems);
	assertGeneralCompatibilityProblem(resource, problems);
	}

	@Test
	public void allProblems_EObject_crossReferencer() {
	CDOTransaction transaction = createTransaction();
	CDOResource resource = transaction
	.createResource(getResourcePath("/resource1"));

	// attach a cross-reference adapter
	transaction.getResourceSet().eAdapters()
	.add(new ECrossReferenceAdapter());

	createTestModel(resource);
	final int expectedProblems = computeExpectedProblemsCount(getClass2());

	ProblemsManager mgr = getProblemsManager(transaction);
	mgr.addDiagnostic(validate(resource));

	Collection<EProblem> problems = collect(mgr
	.getAllProblems(getClass2(resource)));
	assertThat(problems.size(), equalTo(expectedProblems));
	assertIndistinguishableMembersProblem(resource, problems);
	assertGeneralCompatibilityProblem(resource, problems);
	}

	@Test
	public void purgeAll_noCrossReferencer() {
	CDOTransaction transaction = createTransaction();
	CDOResource resource = transaction
	.createResource(getResourcePath("/resource1"));

	createTestModel(resource);

	ProblemsManager mgr = getProblemsManager(transaction);
	mgr.addDiagnostic(validate(resource));

	mgr.purgeAllProblems();

	assertThat(mgr.getAllProblems().hasNext(), is(false));
	}

	@Test
	public void purgeAll_crossReferencer() {
	CDOTransaction transaction = createTransaction();
	CDOResource resource = transaction
	.createResource(getResourcePath("/resource1"));

	// attach a cross-reference adapter
	transaction.getResourceSet().eAdapters()
	.add(new ECrossReferenceAdapter());

	createTestModel(resource);

	ProblemsManager mgr = getProblemsManager(transaction);
	mgr.addDiagnostic(validate(resource));

	mgr.purgeAllProblems();

	assertThat(mgr.getAllProblems().hasNext(), is(false));
	}

	@Test
	public void purge_noCrossReferencer() {
	CDOTransaction transaction = createTransaction();
	CDOResource resource = transaction
	.createResource(getResourcePath("/resource1"));

	createTestModel(resource);
	final int expectedTotalProblems = computeExpectedProblemsCount();
	final int expectedClass3Problems = computeExpectedProblemsCount(getClass3());

	ProblemsManager mgr = getProblemsManager(transaction);
	mgr.addDiagnostic(validate(resource));

	mgr.purgeProblems(getClass3(resource));

	Collection<EProblem> problems = collect(mgr.getAllProblems());
	assertThat(problems.size(), equalTo(expectedTotalProblems - expectedClass3Problems));
	assertIndistinguishableMembersProblem(resource, problems);
	assertGeneralCompatibilityProblem(resource, problems);
	}

	@Test
	public void purge_crossReferencer() {
	CDOTransaction transaction = createTransaction();
	CDOResource resource = transaction
	.createResource(getResourcePath("/resource1"));

	// attach a cross-reference adapter
	transaction.getResourceSet().eAdapters()
	.add(new ECrossReferenceAdapter());

	createTestModel(resource);
	final int expectedTotalProblems = computeExpectedProblemsCount();
	final int expectedClass3Problems = computeExpectedProblemsCount(getClass3());

	ProblemsManager mgr = getProblemsManager(transaction);
	mgr.addDiagnostic(validate(resource));

	mgr.purgeProblems(getClass3(resource));

	Collection<EProblem> problems = collect(mgr.getAllProblems());
	assertThat(problems.size(), equalTo(expectedTotalProblems - expectedClass3Problems));
	assertIndistinguishableMembersProblem(resource, problems);
	assertGeneralCompatibilityProblem(resource, problems);
	}

	@Test
	public void disposeProblemsManager()
	throws Exception {

	CDOTransaction transaction = createTransaction();
	CDOResource resource = transaction
	.createResource(getResourcePath("/resource1"));

	// attach a cross-reference adapter
	ECrossReferenceAdapter xrefs = new ECrossReferenceAdapter();
	transaction.getResourceSet().eAdapters().add(xrefs);

	createTestModel(resource);

	ProblemsManager mgr = getProblemsManager(transaction);
	mgr.addDiagnostic(validate(resource));

	// gather weak references to the problems
	ReferenceQueue<EProblem> queue = new ReferenceQueue<EProblem>();
	List<Reference<EProblem>> references = new java.util.ArrayList<Reference<EProblem>>(
	3);
	for (Iterator<EProblem> iter = mgr.getAllProblems(); iter.hasNext();) {
	references.add(new WeakReference<EProblem>(iter.next(), queue));
	}

	mgr.dispose();

	// try to force GC
	for (int i = 0; i < 10; i++) {
	System.gc();
	}

	// assert that the problems are unreachable
	for (int i = 0; i < 3; i++) {
	Reference<? extends EProblem> ref = queue.remove(1000);
	assertThat(ref, notNullValue());
	}
	}

	@Test
	public void dispose_crossReferencerAddedAfter()
	throws Exception {

	CDOTransaction transaction = createTransaction();
	CDOResource resource = transaction
	.createResource(getResourcePath("/resource1"));

	createTestModel(resource);

	ProblemsManager mgr = getProblemsManager(transaction);
	mgr.addDiagnostic(validate(resource));

	// attach a cross-reference adapter after adding problems
	ECrossReferenceAdapter xrefs = new ECrossReferenceAdapter();
	transaction.getResourceSet().eAdapters().add(xrefs);

	// gather weak references to the problems
	ReferenceQueue<EProblem> queue = new ReferenceQueue<EProblem>();
	List<Reference<EProblem>> references = new java.util.ArrayList<Reference<EProblem>>(
	3);
	for (Iterator<EProblem> iter = mgr.getAllProblems(); iter.hasNext();) {
	references.add(new WeakReference<EProblem>(iter.next(), queue));
	}

	mgr.dispose();

	// try to force GC
	for (int i = 0; i < 10; i++) {
	System.gc();
	}

	// assert that the problems are unreachable
	for (int i = 0; i < 3; i++) {
	Reference<? extends EProblem> ref = queue.remove(1000);
	assertThat(ref, notNullValue());
	}
	}

	@Test
	public void customProblemClass() {
	CDOTransaction transaction = createTransaction();
	CDOResource resource = transaction
	.createResource(getResourcePath("/resource1"));

	createTestModel(resource);
	final int expectedProblems = computeExpectedProblemsCount();

	// not actually a different class, but a different way of creating it
	ProblemsManager mgr = ProblemsManager.createProblemsManager(
	transaction.getResourceSet(), ProblemsPackage.Literals.EPROBLEM);
	managers.add(mgr);
	mgr.addDiagnostic(validate(resource));

	Collection<EProblem> allProblems = collect(mgr.getAllProblems());
	assertThat(allProblems.size(), equalTo(expectedProblems));
	assertIndistinguishableMembersProblem(resource, allProblems);
	assertGeneralCompatibilityProblem(resource, allProblems);
	assertUnownedElementProblem(resource, allProblems);
	}

	//
	// Test framework
	//

	@After
	public void disposeProblemManagers()
	throws Exception {

	for (ProblemsManager next : managers) {
	next.dispose();
	}
	}

	void createTestModel(Resource res) {
	Model model = UMLFactory.eINSTANCE.createModel();
	model.setName("testmodel");
	res.getContents().add(model);

	Class class1 = model.createOwnedClass("Class1", false);

	Interface interface1 = model.createOwnedInterface("Interface1");

	Class class2 = model.createOwnedClass("Class2", false);
	class2.createGeneralization(interface1); // invalid generalization
	class2.createOwnedAttribute("attr1", class1);
	class2.createOwnedAttribute("attr1", class1); // indistinguishable

	Class class3 = UMLFactory.eINSTANCE.createClass();
	class3.setName("Class3");
	res.getContents().add(class3); // not owned
	}

	int computeExpectedProblemsCount() {
	int result;

	Resource resource = createScratchResource();

	try {
	Diagnostic diagnostic = validate(resource);
	result = diagnostic.getChildren().size();
	} finally {
	unload(resource);
	}

	return result;
	}

	int computeExpectedProblemsCount(Function<Resource, ? extends EObject> pertainingTo) {
	int result;

	Resource resource = createScratchResource();
	final EObject target = pertainingTo.apply(resource);

	try {
	Diagnostic diagnostic = validate(resource);
	result = Iterables.size(Iterables.filter(diagnostic.getChildren(), new Predicate<Diagnostic>() {
	@Override
	public boolean apply(Diagnostic input) {
	List<?> data = input.getData();
	return (data != null) && !data.isEmpty() && (data.get(0) == target);
	}
	}));
	} finally {
	unload(resource);
	}

	return result;
	}

	Resource createScratchResource() {
	Resource result = UMLResource.Factory.INSTANCE.createResource(URI.createURI("bogus://scratch.uml"));
	createTestModel(result);
	return result;
	}

	void unload(Resource resource) {
	resource.unload();
	if (resource.getResourceSet() != null) {
	resource.getResourceSet().getResources().remove(resource);
	}
	resource.eAdapters().clear();
	}

	Model getModel(Resource resource) {
	return (Model) EcoreUtil.getObjectByType(resource.getContents(),
	UMLPackage.Literals.MODEL);
	}

	Class getClass1(Resource resource) {
	return getClass1().apply(resource);
	}

	Function<Resource, Class> getClass1() {
	return getNamedClass("Class1");
	}

	Function<Resource, Class> getNamedClass(final String name) {
	return new Function<Resource, Class>() {
	@Override
	public Class apply(Resource input) {
	return (Class) getModel(input).getOwnedType(name);
	}
	};
	}

	Class getClass2(Resource resource) {
	return getClass2().apply(resource);
	}

	Function<Resource, Class> getClass2() {
	return getNamedClass("Class2");
	}

	Class getClass3(Resource resource) {
	return getClass3().apply(resource);
	}

	Function<Resource, Class> getClass3() {
	return getRoot(Class.class);
	}

	<T extends EObject> Function<Resource, T> getRoot(final java.lang.Class<T> metaclass) {
	return new Function<Resource, T>() {
	@Override
	public T apply(Resource input) {
	return Iterables.getFirst(Iterables.filter(input.getContents(), metaclass), null);
	}
	};
	}

	Interface getInterface1(Resource resource) {
	return (Interface) getModel(resource).getOwnedType("Interface1");
	}

	ProblemsManager getProblemsManager(CDOView view) {
	return getProblemsManager(view.getResourceSet());
	}

	ProblemsManager getProblemsManager(ResourceSet resourceSet) {
	ProblemsManager result = ProblemsManager
	.getProblemsManager(resourceSet);
	managers.add(result);
	return result;
	}

	Diagnostic validate(Resource resource) {
	EValidator.Registry registry = new EValidatorRegistryImpl(
	EValidator.Registry.INSTANCE);
	registry.put(UMLPackage.eINSTANCE, new UMLValidator());

	BasicDiagnostic result = new BasicDiagnostic();
	Diagnostician diagnostician = new Diagnostician(registry);

	for (EObject next : resource.getContents()) {
	diagnostician.validate(next, result);
	}

	return result;
	}

	Collection<EProblem> collect(Iterator<? extends EProblem> problems) {
	Collection<EProblem> result = new java.util.ArrayList<EProblem>();

	while (problems.hasNext()) {
	result.add(problems.next());
	}

	return result;
	}

	void assertProblem(Collection<EProblem> problems, ESeverity severity,
	String source, int code, String messagePattern, EObject element,
	EObject... related) {

	final List<EObject> relatedList = Arrays.asList(related);
	final Pattern pattern = Pattern.compile(messagePattern);

	EProblem found = null;
	for (EProblem problem : problems) {
	if (problem.getElement() == element //
	&& problem.getRelated().equals(relatedList) //
	&& problem.getSeverity() == severity //
	&& pattern.matcher(problem.getMessage()).find() //
	&& source.equals(problem.getSource()) //
	&& problem.getCode() == code) {
	found = problem;
	break;
	}
	}

	assertThat(found, notNullValue());
	}

	void assertIndistinguishableMembersProblem(Resource resource,
	Collection<EProblem> problems) {

	Class class2 = getClass2(resource);

	assertProblem(problems, ESeverity.WARNING,
	UMLValidator.DIAGNOSTIC_SOURCE,
	UMLValidator.NAMESPACE__MEMBERS_DISTINGUISHABLE, "disting", class2);
	}

	void assertGeneralCompatibilityProblem(Resource resource,
	Collection<EProblem> problems) {

	Class class2 = getClass2(resource);
	Interface interface1 = getInterface1(resource);

	assertProblem(problems, ESeverity.WARNING,
	UMLValidator.DIAGNOSTIC_SOURCE,
	UMLValidator.CLASSIFIER__SPECIALIZE_TYPE, "special", class2,
	interface1);
	}

	void assertUnownedElementProblem(Resource resource,
	Collection<EProblem> problems) {

	Class class3 = getClass3(resource);

	assertProblem(problems, ESeverity.WARNING,
	UMLValidator.DIAGNOSTIC_SOURCE, UMLValidator.ELEMENT__HAS_OWNER,
	"owned", class3);
	}
	}