CompareTransformationEngineTest.java

package org.eclipse.gmf.tests.tr;

import java.util.List;
import java.util.Map.Entry;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.codegen.ecore.genmodel.GenFeature;
import org.eclipse.emf.codegen.ecore.genmodel.GenModel;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.gmf.codegen.gmfgen.AbstractToolEntry;
import org.eclipse.gmf.codegen.gmfgen.Attributes;
import org.eclipse.gmf.codegen.gmfgen.Behaviour;
import org.eclipse.gmf.codegen.gmfgen.ColorAttributes;
import org.eclipse.gmf.codegen.gmfgen.DefaultSizeAttributes;
import org.eclipse.gmf.codegen.gmfgen.ElementType;
import org.eclipse.gmf.codegen.gmfgen.ExpressionLabelParser;
import org.eclipse.gmf.codegen.gmfgen.ExternalParser;
import org.eclipse.gmf.codegen.gmfgen.FeatureLabelModelFacet;
import org.eclipse.gmf.codegen.gmfgen.FigureViewmap;
import org.eclipse.gmf.codegen.gmfgen.GMFGenPackage;
import org.eclipse.gmf.codegen.gmfgen.GenAuditContainer;
import org.eclipse.gmf.codegen.gmfgen.GenAuditRoot;
import org.eclipse.gmf.codegen.gmfgen.GenAuditRule;
import org.eclipse.gmf.codegen.gmfgen.GenAuditable;
import org.eclipse.gmf.codegen.gmfgen.GenChildNode;
import org.eclipse.gmf.codegen.gmfgen.GenCommonBase;
import org.eclipse.gmf.codegen.gmfgen.GenCompartment;
import org.eclipse.gmf.codegen.gmfgen.GenContextMenu;
import org.eclipse.gmf.codegen.gmfgen.GenContributionItem;
import org.eclipse.gmf.codegen.gmfgen.GenCustomPreferencePage;
import org.eclipse.gmf.codegen.gmfgen.GenDiagram;
import org.eclipse.gmf.codegen.gmfgen.GenDomainAttributeTarget;
import org.eclipse.gmf.codegen.gmfgen.GenDomainElementTarget;
import org.eclipse.gmf.codegen.gmfgen.GenEditorGenerator;
import org.eclipse.gmf.codegen.gmfgen.GenEditorView;
import org.eclipse.gmf.codegen.gmfgen.GenLink;
import org.eclipse.gmf.codegen.gmfgen.GenLinkLabel;
import org.eclipse.gmf.codegen.gmfgen.GenNode;
import org.eclipse.gmf.codegen.gmfgen.GenNodeLabel;
import org.eclipse.gmf.codegen.gmfgen.GenNotationElementTarget;
import org.eclipse.gmf.codegen.gmfgen.GenParserImplementation;
import org.eclipse.gmf.codegen.gmfgen.GenParsers;
import org.eclipse.gmf.codegen.gmfgen.GenPlugin;
import org.eclipse.gmf.codegen.gmfgen.GenPreferencePage;
import org.eclipse.gmf.codegen.gmfgen.GenStandardPreferencePage;
import org.eclipse.gmf.codegen.gmfgen.GenTopLevelNode;
import org.eclipse.gmf.codegen.gmfgen.InnerClassViewmap;
import org.eclipse.gmf.codegen.gmfgen.LabelModelFacet;
import org.eclipse.gmf.codegen.gmfgen.LabelOffsetAttributes;
import org.eclipse.gmf.codegen.gmfgen.LinkModelFacet;
import org.eclipse.gmf.codegen.gmfgen.ModeledViewmap;
import org.eclipse.gmf.codegen.gmfgen.OpenDiagramBehaviour;
import org.eclipse.gmf.codegen.gmfgen.Palette;
import org.eclipse.gmf.codegen.gmfgen.ParentAssignedViewmap;
import org.eclipse.gmf.codegen.gmfgen.ResizeConstraints;
import org.eclipse.gmf.codegen.gmfgen.SharedBehaviour;
import org.eclipse.gmf.codegen.gmfgen.SnippetViewmap;
import org.eclipse.gmf.codegen.gmfgen.StandardEntry;
import org.eclipse.gmf.codegen.gmfgen.StyleAttributes;
import org.eclipse.gmf.codegen.gmfgen.ToolEntry;
import org.eclipse.gmf.codegen.gmfgen.ToolGroup;
import org.eclipse.gmf.codegen.gmfgen.ToolGroupItem;
import org.eclipse.gmf.codegen.gmfgen.TypeLinkModelFacet;
import org.eclipse.gmf.codegen.gmfgen.TypeModelFacet;
import org.eclipse.gmf.codegen.gmfgen.ValueExpression;
import org.eclipse.gmf.codegen.gmfgen.Viewmap;
import org.eclipse.gmf.mappings.Mapping;
import org.eclipse.gmf.tests.ConfiguredTestCase;
import org.eclipse.gmf.tests.tr.TransformationTestSupport.Transformation;

/**
 * Compare results form Java & QVTO transformations.
 * 
 * @author ghillairet
 *
 */
public class CompareTransformationEngineTest extends ConfiguredTestCase {
	protected static String testFolder = "platform:/plugin/org.eclipse.gmf.tests/models/tests/";  //$NON-NLS-1$

	public CompareTransformationEngineTest(String name) {
		super(name);
	}

	protected GenModel genModel;
	protected Mapping mapping;
	protected GenEditorGenerator expectedGenerator;
	protected GenEditorGenerator actualGenerator;

	private IProject myProject;
	private URI traceURI;

	// map -> test.gmfmap
	// ecore -> test.ecore
	// genmodel -> test.genmodel
	@Override
	public void setUp() throws Exception {
		super.setUp();
		myProject = createProject();
		traceURI = URI.createURI(myProject.getFile("test.trace").getFullPath().toString());

		ResourceSet resourceSet = new ResourceSetImpl();
		Resource mapRes = resourceSet.createResource(URI.createURI(testFolder+"test.gmfmap"));
		mapRes.load(null);
		Resource genRes = resourceSet.createResource(URI.createURI(testFolder+"test.genmodel"));
		genRes.load(null);

		mapping = (Mapping) mapRes.getContents().get(0);
		genModel = (GenModel) genRes.getContents().get(0);

		Transformation java = TransformationTestSupport.getJavaTransformation(genModel, mapping, false);
		Transformation qvt = TransformationTestSupport.getQvtTransformation(genModel, mapping, false);

		expectedGenerator = java.execute(traceURI.trimFileExtension().appendFileExtension("java.gmfgen"));
		actualGenerator = qvt.execute(traceURI.trimFileExtension().appendFileExtension("qvt.gmfgen"));
	}

	@Override
	public void tearDown() throws Exception {
		deleteProject();
		myProject = null;
		super.tearDown();
	}

	public void testDummy() {
		// TODO: Remove when ParsersTest fixed.
	}
	
	public void testGenEditorGenerator() {
		assertNotNull(expectedGenerator);
		assertNotNull(actualGenerator);
		assertNotSame(expectedGenerator, actualGenerator);
		assertNotNull(expectedGenerator.eResource());
		assertNotNull(actualGenerator.eResource());

		assertNotSame(expectedGenerator.eResource(), actualGenerator.eResource());
		assertSame(expectedGenerator.eResource().getResourceSet(), actualGenerator.eResource().getResourceSet());

		assertEquals(expectedGenerator.getCopyrightText(), actualGenerator.getCopyrightText());
		assertEquals(expectedGenerator.getDiagramFileExtension(), actualGenerator.getDiagramFileExtension());
		assertEquals(expectedGenerator.getDomainFileExtension(), actualGenerator.getDomainFileExtension());
		assertEquals(expectedGenerator.getModelID(), actualGenerator.getModelID());
		assertEquals(expectedGenerator.getPackageNamePrefix(), actualGenerator.getPackageNamePrefix());
		assertEquals(expectedGenerator.getPluginDirectory(), actualGenerator.getPluginDirectory());
		assertEquals(expectedGenerator.getTemplateDirectory(), actualGenerator.getTemplateDirectory());
	}

	public void testGenEditorView() {
		GenEditorView expected = expectedGenerator.getEditor();
		GenEditorView actual = actualGenerator.getEditor();

		assertEquals(expected.getActionBarContributorClassName(), actual.getActionBarContributorClassName());
		assertEquals(expected.getClassName(), actual.getClassName());
		assertEquals(expected.getContextID(), actual.getContextID());
		assertEquals(expected.isEclipseEditor(), actual.isEclipseEditor());
		assertEquals(expected.getIconPath(), actual.getIconPath());
		assertEquals(expected.getIconPathX(), actual.getIconPathX());
		assertEquals(expected.getID(), actual.getID());
		assertEquals(expected.getPackageName(), actual.getPackageName());

		assertEquals(expected.getActionBarContributorQualifiedClassName(), actual.getActionBarContributorQualifiedClassName());
		assertEquals(expected.getQualifiedClassName(), actual.getQualifiedClassName());
	}

	public void testGenPlugin() {
		GenPlugin expected = expectedGenerator.getPlugin();
		GenPlugin actual = actualGenerator.getPlugin();

		assertNotNull(expected);
		assertNotNull(actual);

		assertEquals(expected.getActivatorClassName(), actual.getActivatorClassName());
		assertEquals(expected.getID(), actual.getID());
		assertEquals(expected.getName(), actual.getName());
		assertEquals(expected.isPrintingEnabled(), actual.isPrintingEnabled());
		assertEquals(expected.getProvider(), actual.getProvider());
		assertEquals(expected.getVersion(), actual.getVersion());

		assertEquals(expected.getRequiredPlugins().size(), actual.getRequiredPlugins().size());
		List<String> actualPlugins = actual.getRequiredPlugins();
		for (int i=0; i<expected.getRequiredPlugins().size(); i++) {
			String exp = expected.getRequiredPlugins().get(i);
			assertTrue(actualPlugins.contains(exp));
		}
	}

	public void testContextMenus() {
		EList<GenContextMenu> expected = expectedGenerator.getContextMenus();
		EList<GenContextMenu> actual = actualGenerator.getContextMenus();

		assertEquals(expected.size(), actual.size());
		for (int i=0; i<expected.size(); i++) {
			GenContextMenu exp = expected.get(i);
			GenContextMenu act = actual.get(i);

			assertEquals(exp.getID(), act.getID());
			assertEquals(exp.getItems().size(), act.getItems().size());
		}
	}

	protected void testGenContributionItem(GenContributionItem expected, GenContributionItem actual) {
		// TODO
	}

	public void testNumberOfElementsInGenDiagram() {
		GenDiagram expected = expectedGenerator.getDiagram();
		GenDiagram actual = actualGenerator.getDiagram();

		assertEquals(expected.getTopLevelNodes().size(), actual.getTopLevelNodes().size());
		assertEquals(expected.getChildNodes().size(), actual.getChildNodes().size());
		assertEquals(expected.getCompartments().size(), actual.getCompartments().size());
		assertEquals(expected.getLinks().size(), actual.getLinks().size());
	}

	public void testGenDiagram() {
		GenDiagram expected = expectedGenerator.getDiagram();
		GenDiagram actual = actualGenerator.getDiagram();

		assertNotNull(expected);
		assertNotNull(actual);

		assertEquals(expected.getDiagramRunTimeClass().getName(), actual.getDiagramRunTimeClass().getName());

		for (EAttribute attribute: GMFGenPackage.eINSTANCE.getGenDiagram().getEAllAttributes()) {
			if (expected.eIsSet(attribute)) {
				assertTrue(attribute+" should be set", actual.eIsSet(attribute));

				if (!attribute.isMany()) {
					assertEquals(expected.eGet(attribute), actual.eGet(attribute));
				}
			} else {
				assertFalse(attribute+" should not be set", actual.eIsSet(attribute));
			}
		}
	}

	public void testGenTopLevelNodeVisualID() {
		//	GenTopLevelNode
		EList<GenTopLevelNode> expected = expectedGenerator.getDiagram().getTopLevelNodes();
		EList<GenTopLevelNode> actual = actualGenerator.getDiagram().getTopLevelNodes();

		assertEquals("Number of GenTopLevelNode should be the same", expected.size(), actual.size());
		for (int i=0; i<expected.size(); i++) {
			GenTopLevelNode exp = expected.get(i);
			GenTopLevelNode act = actual.get(i);

			assertEquals("Node visualID should be the same", exp.getVisualID(), act.getVisualID());

			EList<GenNodeLabel> expLabels = exp.getLabels();
			EList<GenNodeLabel> actLabels = act.getLabels();

			assertEquals("Number of GenNodeLabel should be the same", expLabels.size(), actLabels.size());
			for (int j=0; j<expLabels.size(); j++) {
				GenNodeLabel expLabel = expLabels.get(j);
				GenNodeLabel actLabel = actLabels.get(j);

				assertEquals("Node visualID should be the same", expLabel.getVisualID(), actLabel.getVisualID());
			}
		}
	}

	public void testGenChildNodeVisualID() {
		// GenChildNode
		EList<GenChildNode> expChildNodes = expectedGenerator.getDiagram().getChildNodes();
		EList<GenChildNode> actChildNodes = actualGenerator.getDiagram().getChildNodes();

		assertEquals("Number of GenChildNode should be the same", expChildNodes.size(), actChildNodes.size());
		for (int i=0; i<expChildNodes.size(); i++) {
			GenChildNode exp = expChildNodes.get(i);
			GenChildNode act = actChildNodes.get(i);

			assertEquals("Node visualID should be the same", exp.getVisualID(), act.getVisualID());

			EList<GenNodeLabel> expLabels = exp.getLabels();
			EList<GenNodeLabel> actLabels = act.getLabels();

			assertEquals("Number of GenNodeLabel should be the same", expLabels.size(), actLabels.size());
			for (int j=0; j<expLabels.size(); j++) {
				GenNodeLabel expLabel = expLabels.get(j);
				GenNodeLabel actLabel = actLabels.get(j);

				assertEquals("Node visualID should be the same", expLabel.getVisualID(), actLabel.getVisualID());
			}
		}
	}

	public void testGenLinkVisualID() {
		// GenLink
		EList<GenLink> expLinks = expectedGenerator.getDiagram().getLinks();
		EList<GenLink> actLinks = actualGenerator.getDiagram().getLinks();

		assertEquals("Number of GenLink should be the same", expLinks.size(), actLinks.size());
		for (int i=0; i<expLinks.size(); i++) {
			GenLink exp = expLinks.get(i);
			GenLink act = actLinks.get(i);

			assertEquals("Node visualID should be the same", exp.getVisualID(), act.getVisualID());

			EList<GenLinkLabel> expLabels = exp.getLabels();
			EList<GenLinkLabel> actLabels = act.getLabels();

			assertEquals("Number of GenNodeLabel should be the same", expLabels.size(), actLabels.size());
			for (int j=0; j<expLabels.size(); j++) {
				GenLinkLabel expLabel = expLabels.get(j);
				GenLinkLabel actLabel = actLabels.get(j);

				assertEquals("Node visualID should be the same", expLabel.getVisualID(), actLabel.getVisualID());
			}
		}
	}

	public void testGenCompartmentVisualID() {
		// GenCompartment
		EList<GenCompartment> expCompartments = expectedGenerator.getDiagram().getCompartments();
		EList<GenCompartment> actCompartments = actualGenerator.getDiagram().getCompartments();
		// Known issue: GenCompartment are not set in same order.
		assertEquals("Number of GenLink should be the same", expCompartments.size(), actCompartments.size());
		for (int i=0; i<expCompartments.size(); i++) {
			GenCompartment exp = expCompartments.get(i);
			GenCompartment act = findCompartment(exp, actCompartments);
			assertNotNull("Identical GenCompartment should be found", act);
			assertEquals("Node visualID should be the same", exp.getVisualID(), act.getVisualID());
		}
	}

	public void testGenTopLevelNodeAttributes() {
		//	GenTopLevelNode
		EList<GenTopLevelNode> expected = expectedGenerator.getDiagram().getTopLevelNodes();
		EList<GenTopLevelNode> actual = actualGenerator.getDiagram().getTopLevelNodes();

		assertEquals("Number of GenLink should be the same", expected.size(), actual.size());

		for (int i=0; i<expected.size(); i++) {
			GenTopLevelNode exp = expected.get(i);
			GenTopLevelNode act = actual.get(i);

			assertEquals(exp.getCanonicalEditPolicyClassName(), act.getCanonicalEditPolicyClassName());
			assertEquals(exp.getCanonicalEditPolicyQualifiedClassName(), act.getCanonicalEditPolicyQualifiedClassName());
			assertEquals(exp.getClassNamePrefix(), act.getClassNamePrefix());
			assertEquals(exp.getClassNameSuffux(), act.getClassNameSuffux());
			assertEquals(exp.getCreateCommandClassName(), act.getCreateCommandClassName());
			assertEquals(exp.getCreateCommandQualifiedClassName(), act.getCreateCommandQualifiedClassName());
			assertEquals(exp.getEditPartClassName(), act.getEditPartClassName());
			assertEquals(exp.getEditPartQualifiedClassName(), act.getEditPartQualifiedClassName());
			assertEquals(exp.getGraphicalNodeEditPolicyClassName(), act.getGraphicalNodeEditPolicyClassName());
			assertEquals(exp.getGraphicalNodeEditPolicyQualifiedClassName(), act.getGraphicalNodeEditPolicyQualifiedClassName());
			assertEquals(exp.getItemSemanticEditPolicyClassName(), act.getItemSemanticEditPolicyClassName());
			assertEquals(exp.getItemSemanticEditPolicyQualifiedClassName(), act.getItemSemanticEditPolicyQualifiedClassName());
			assertEquals(exp.getNotationViewFactoryClassName(), act.getNotationViewFactoryClassName());
			assertEquals(exp.getNotationViewFactoryQualifiedClassName(), act.getNotationViewFactoryQualifiedClassName());
			assertEquals(exp.getPrimaryDragEditPolicyQualifiedClassName(), act.getPrimaryDragEditPolicyQualifiedClassName());
			assertEquals(exp.getUniqueIdentifier(), act.getUniqueIdentifier());
			assertEquals(exp.getVisualID(), act.getVisualID());
		}
	}
	
	public void testGenChildNodeAttributes() {
		//		GenChildNode
		EList<GenChildNode> expected = expectedGenerator.getDiagram().getChildNodes();
		EList<GenChildNode> actual = actualGenerator.getDiagram().getChildNodes();

		assertEquals("Number of GenChildNode should be the same", expected.size(), actual.size());

		for (int i=0; i<expected.size(); i++) {
			GenChildNode exp = expected.get(i);
			GenChildNode act = actual.get(i);

			assertEquals(exp.eClass(), act.eClass());

			for (EAttribute attribute: exp.eClass().getEAllAttributes()) {
				if (exp.eIsSet(attribute)) {
					assertTrue(attribute+" should be set", act.eIsSet(attribute));

					if (!attribute.isMany()) {
						assertEquals(exp.eGet(attribute), act.eGet(attribute));
					}
				} else {
					assertFalse(attribute+" should not be set", act.eIsSet(attribute));
				}	
			}
		}
	}
	
	public void testGenLinksAttributes() {		
		//	GenLink
		EList<GenLink> expected = expectedGenerator.getDiagram().getLinks();
		EList<GenLink> actual = actualGenerator.getDiagram().getLinks();

		assertEquals("Number of GenLink should be the same", expected.size(), actual.size());

		for (int i=0; i<expected.size(); i++) {
			GenLink expLink = expected.get(i);
			GenLink actLink = actual.get(i);

			assertEquals(expLink.getClassNamePrefix(), actLink.getClassNamePrefix());
			assertEquals(expLink.getClassNameSuffux(), actLink.getClassNameSuffux());
			assertEquals(expLink.getCreateCommandClassName(), actLink.getCreateCommandClassName());
			assertEquals(expLink.getCreateCommandQualifiedClassName(), actLink.getCreateCommandQualifiedClassName());
			assertEquals(expLink.getEditPartClassName(), actLink.getEditPartClassName());
			assertEquals(expLink.getEditPartQualifiedClassName(), actLink.getEditPartQualifiedClassName());
			assertEquals(expLink.getItemSemanticEditPolicyClassName(), actLink.getItemSemanticEditPolicyClassName());
			assertEquals(expLink.getItemSemanticEditPolicyQualifiedClassName(), actLink.getItemSemanticEditPolicyQualifiedClassName());
			assertEquals(expLink.getNotationViewFactoryClassName(), actLink.getNotationViewFactoryClassName());
			assertEquals(expLink.getNotationViewFactoryQualifiedClassName(), actLink.getNotationViewFactoryQualifiedClassName());
			assertEquals(expLink.getReorientCommandClassName(), actLink.getReorientCommandClassName());
			assertEquals(expLink.getReorientCommandQualifiedClassName(), actLink.getReorientCommandQualifiedClassName());
			assertEquals(expLink.getVisualID(), actLink.getVisualID());
			assertEquals(expLink.getUniqueIdentifier(), actLink.getUniqueIdentifier());
		}
	}
	
	public void testGenCompartmentAttributes() {
		// GenCompartment
		EList<GenCompartment> expCompartments = expectedGenerator.getDiagram().getCompartments();
		EList<GenCompartment> actCompartments = actualGenerator.getDiagram().getCompartments();
		// Known issue: GenCompartment are not set in same order.
		assertEquals("Number of GenLink should be the same", expCompartments.size(), actCompartments.size());
		for (int i=0; i<expCompartments.size(); i++) {
			GenCompartment exp = expCompartments.get(i);
			GenCompartment act = findCompartment(exp, actCompartments);
			assertNotNull("Compartment with ID "+exp.getVisualID()+" not found", act);
			
			assertEquals("Node visualID should be the same", exp.getVisualID(), act.getVisualID());
			assertEquals(exp.getCanonicalEditPolicyClassName(), act.getCanonicalEditPolicyClassName());
			assertEquals(exp.getCanonicalEditPolicyQualifiedClassName(), act.getCanonicalEditPolicyQualifiedClassName());
			assertEquals(exp.getClassNamePrefix(), act.getClassNamePrefix());
			assertEquals(exp.getClassNameSuffux(), act.getClassNameSuffux());
			assertEquals(exp.getEditPartClassName(), act.getEditPartClassName());
			assertEquals(exp.getEditPartQualifiedClassName(), act.getEditPartQualifiedClassName());
			assertEquals(exp.getItemSemanticEditPolicyClassName(), act.getItemSemanticEditPolicyClassName());
			assertEquals(exp.getItemSemanticEditPolicyQualifiedClassName(), act.getItemSemanticEditPolicyQualifiedClassName());
			assertEquals(exp.getNotationViewFactoryClassName(), act.getNotationViewFactoryClassName());
			assertEquals(exp.getNotationViewFactoryQualifiedClassName(), act.getNotationViewFactoryQualifiedClassName());
			assertEquals(exp.getTitle(), act.getTitle());
			assertEquals(exp.getUniqueIdentifier(), act.getUniqueIdentifier());
			assertEquals(exp.isCanCollapse(), act.isCanCollapse());
			assertEquals(exp.isHideIfEmpty(), act.isHideIfEmpty());
			assertEquals(exp.isListLayout(), act.isListLayout());
			assertEquals(exp.isNeedsTitle(), act.isNeedsTitle());
			assertEquals(exp.isSansDomain(), act.isSansDomain());
		}
	}

	public void testGenTopLevelNodeReferences() {
		//	GenTopLevelNode
		EList<GenTopLevelNode> expected = expectedGenerator.getDiagram().getTopLevelNodes();
		EList<GenTopLevelNode> actual = actualGenerator.getDiagram().getTopLevelNodes();
	
		assertEquals("Number of GenLink should be the same", expected.size(), actual.size());
	
		for (int i=0; i<expected.size(); i++) {
			GenTopLevelNode exp = expected.get(i);
			GenTopLevelNode act = actual.get(i);
	
			testElementType(exp.getElementType(), act.getElementType());
			testViewmap(exp.getViewmap(), act.getViewmap());
			testBehaviours(exp.getBehaviour(),act.getBehaviour());
			testTypeModelFacet(exp.getModelFacet(), act.getModelFacet());
			testGenNodeLabels(exp.getLabels(), act.getLabels());
			
			assertEquals(exp.getDiagramRunTimeClass().getName(), act.getDiagramRunTimeClass().getName());
			assertEquals(exp.getStyles().size(), act.getStyles().size());
			assertEquals(exp.getBehaviour().size(), act.getBehaviour().size());
			assertEquals(exp.getContainedNodes().size(), act.getContainedNodes().size());
			assertEquals(exp.getCompartments().size(), act.getCompartments().size());
			assertEquals(exp.getGenIncomingLinks().size(), act.getGenIncomingLinks().size());
			assertEquals(exp.getGenOutgoingLinks().size(), act.getGenOutgoingLinks().size());
			assertEquals(exp.getReorientedIncomingLinks().size(), act.getReorientedIncomingLinks().size());
		}
	}

	public void testGenChildNodeReferences() {
		//		GenChildNode
		EList<GenChildNode> expected = expectedGenerator.getDiagram().getChildNodes();
		EList<GenChildNode> actual = actualGenerator.getDiagram().getChildNodes();
	
		assertEquals("Number of GenChildNode should be the same", expected.size(), actual.size());
	
		for (int i=0; i<expected.size(); i++) {
			GenChildNode exp = expected.get(i);
			GenChildNode act = actual.get(i);
			
			testElementType(exp.getElementType(), act.getElementType());
			testViewmap(exp.getViewmap(), act.getViewmap());
			testBehaviours(exp.getBehaviour(),act.getBehaviour());
			testTypeModelFacet(exp.getModelFacet(), act.getModelFacet());
			testGenNodeLabels(exp.getLabels(), act.getLabels());
			
			assertEquals(exp.getDiagramRunTimeClass().getName(), act.getDiagramRunTimeClass().getName());
			assertEquals(exp.getStyles().size(), act.getStyles().size());
			assertEquals(exp.getBehaviour().size(), act.getBehaviour().size());
			assertEquals(exp.getContainedNodes().size(), act.getContainedNodes().size());
			assertEquals(exp.getCompartments().size(), act.getCompartments().size());
			assertEquals(exp.getGenIncomingLinks().size(), act.getGenIncomingLinks().size());
			assertEquals(exp.getGenOutgoingLinks().size(), act.getGenOutgoingLinks().size());
			assertEquals(exp.getReorientedIncomingLinks().size(), act.getReorientedIncomingLinks().size());
		}
	}

	public void testGenLinksReferences() {		
		//	GenTopLevelNode
		EList<GenLink> expected = expectedGenerator.getDiagram().getLinks();
		EList<GenLink> actual = actualGenerator.getDiagram().getLinks();

		assertEquals("Number of GenLink should be the same", expected.size(), actual.size());
		
		for (int i=0; i<expected.size(); i++) {
			GenLink expLink = expected.get(i);
			GenLink actLink = actual.get(i);

			testElementType(expLink.getElementType(), actLink.getElementType());
			testViewmap(expLink.getViewmap(), actLink.getViewmap());
			testBehaviours(expLink.getBehaviour(),actLink.getBehaviour());
			testLinkModelFacet(expLink.getModelFacet(), actLink.getModelFacet());
			
			assertEquals(expLink.getDiagramRunTimeClass().getName(), actLink.getDiagramRunTimeClass().getName());
			assertEquals(expLink.getStyles().size(), actLink.getStyles().size());
			assertEquals(expLink.getBehaviour().size(), actLink.getBehaviour().size());
			assertEquals(expLink.getGenIncomingLinks().size(), actLink.getGenIncomingLinks().size());
			assertEquals(expLink.getGenOutgoingLinks().size(), actLink.getGenOutgoingLinks().size());
			assertEquals(expLink.getLabels().size(), actLink.getLabels().size());
		}
	}
	
	public void testGenCompartmentReferences() {
		// GenCompartment
		EList<GenCompartment> expCompartments = expectedGenerator.getDiagram().getCompartments();
		EList<GenCompartment> actCompartments = actualGenerator.getDiagram().getCompartments();
		// Known issue: GenCompartment are not set in same order.
		assertEquals("Number of GenLink should be the same", expCompartments.size(), actCompartments.size());
		for (int i=0; i<expCompartments.size(); i++) {
			GenCompartment exp = expCompartments.get(i);
			GenCompartment act = findCompartment(exp, actCompartments);
			assertNotNull("Identical GenCompartment should be found", act);
			
			assertNotNull(act.getDiagram());
			
			testElementType(exp.getElementType(), act.getElementType());
			testViewmap(exp.getViewmap(), act.getViewmap());
			testBehaviours(exp.getBehaviour(),act.getBehaviour());
			
			assertEquals(exp.getNode().getVisualID(), act.getNode().getVisualID());
			
			assertEquals(exp.getDiagramRunTimeClass().getName(), act.getDiagramRunTimeClass().getName());
			assertEquals(exp.getStyles().size(), act.getStyles().size());
			assertEquals(exp.getChildNodes().size(), act.getChildNodes().size());
			for (int j=0; j<exp.getChildNodes().size(); j++) {
				GenNode expNode = exp.getChildNodes().get(j);
				GenNode actNode = act.getChildNodes().get(j);
				
				assertEquals(expNode.getVisualID(), actNode.getVisualID());
			}
			assertEquals(exp.getContainedNodes().size(), act.getContainedNodes().size());
			for (int j=0; j<exp.getContainedNodes().size(); j++) {
				GenNode expNode = exp.getContainedNodes().get(j);
				GenNode actNode = act.getContainedNodes().get(j);
				
				assertEquals(expNode.getVisualID(), actNode.getVisualID());
			}
		}
	}
	
	protected void testGenNodeLabels(EList<GenNodeLabel> expected, EList<GenNodeLabel> actual) {
		assertEquals(expected.size(), actual.size());
		for (int i=0; i<expected.size(); i++) {
			GenNodeLabel exp = expected.get(i);
			GenNodeLabel act = actual.get(i);
			assertEquals(exp.eClass(), act.eClass());
			testGenNodeLabel(exp, act);
		}
	}

	protected void testGenNodeLabel(GenNodeLabel expected, GenNodeLabel actual) {
		assertEquals(expected.getVisualID(), actual.getVisualID());
		assertEquals(expected.getUniqueIdentifier(), actual.getUniqueIdentifier());
		assertEquals(expected.getEditPartClassName(), actual.getEditPartClassName());
		assertEquals(expected.getNotationViewFactoryClassName(), actual.getNotationViewFactoryClassName());
		assertEquals(expected.isElementIcon(), actual.isElementIcon());
		assertEquals(expected.isReadOnly(), actual.isReadOnly());
		assertEquals(expected.isSansDomain(), actual.isSansDomain());
		
		assertEquals(expected.getNode().getVisualID(), actual.getNode().getVisualID());
		assertEquals(expected.getNode().getUniqueIdentifier(), actual.getNode().getUniqueIdentifier());
		
		testElementType(expected.getElementType(), actual.getElementType());
		testViewmap(expected.getViewmap(), actual.getViewmap());
		testBehaviours(expected.getBehaviour(), actual.getBehaviour());
		testLabelModelFacet(expected.getModelFacet(), actual.getModelFacet());
		
	}

	private void testLabelModelFacet(LabelModelFacet expected, LabelModelFacet actual) {
		assertEquals(expected.eClass(), actual.eClass());
		assertNotNull(expected.getParser());
		assertNotNull(actual.getParser()); // TODO: assertEquals(Parser, Parser)
		
		if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getFeatureLabelModelFacet())) {
			testFeatureLabelModelFacet((FeatureLabelModelFacet) expected, (FeatureLabelModelFacet) actual);
		}
	}
	
	private void testFeatureLabelModelFacet(FeatureLabelModelFacet expected, FeatureLabelModelFacet actual) {
		assertEquals(expected.getViewPattern(), actual.getViewPattern());
		assertEquals(expected.getEditorPattern(), actual.getEditorPattern());
		assertEquals(expected.getEditPattern(), actual.getEditPattern());
		assertEquals(expected.getViewMethod().getLiteral(), actual.getViewMethod().getLiteral());
		assertEquals(expected.getEditMethod().getLiteral(), actual.getEditMethod().getLiteral());
		
		assertEquals(expected.getMetaFeatures().size(), actual.getMetaFeatures().size());
		for (int i=0; i<expected.getMetaFeatures().size(); i++) {
			GenFeature exp = expected.getMetaFeatures().get(i);
			GenFeature act = actual.getMetaFeatures().get(i);
			
			assertEquals(exp.eClass(), act.eClass());
			assertEquals(exp.getName(), act.getName());
		}
		assertEquals(expected.getEditableMetaFeatures().size(), actual.getEditableMetaFeatures().size());
		for (int i=0; i<expected.getEditableMetaFeatures().size(); i++) {
			GenFeature exp = expected.getMetaFeatures().get(i);
			GenFeature act = actual.getMetaFeatures().get(i);
			
			assertEquals(exp.eClass(), act.eClass());
			assertEquals(exp.getName(), act.getName());
		}
	}

	private void testTypeModelFacet(TypeModelFacet expected, TypeModelFacet actual) {
		assertEquals(expected.eClass(), actual.eClass());
		if (expected.eIsSet(GMFGenPackage.eINSTANCE.getTypeModelFacet_ContainmentMetaFeature())) {
			assertTrue(actual.eIsSet(GMFGenPackage.eINSTANCE.getTypeModelFacet_ContainmentMetaFeature()));
			assertEquals(expected.getContainmentMetaFeature().getName(), actual.getContainmentMetaFeature().getName());
		} else {
			assertFalse(actual.eIsSet(GMFGenPackage.eINSTANCE.getTypeModelFacet_ContainmentMetaFeature()));
		}
		if (expected.eIsSet(GMFGenPackage.eINSTANCE.getTypeModelFacet_ChildMetaFeature())) {
			assertTrue(actual.eIsSet(GMFGenPackage.eINSTANCE.getTypeModelFacet_ChildMetaFeature()));
			assertEquals(expected.getChildMetaFeature().getName(), actual.getChildMetaFeature().getName());
		} else {
			assertFalse(actual.eIsSet(GMFGenPackage.eINSTANCE.getTypeModelFacet_ChildMetaFeature()));
		}
	}

	private void testLinkModelFacet(LinkModelFacet expected, LinkModelFacet actual) {
		if (expected == null) {
			assertNull(actual);
		} else {
			assertNotNull(actual);
			assertEquals(expected.eClass(), actual.eClass());
		}
		
		if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getTypeLinkModelFacet())) {
			testTypeLinkModelFacet((TypeLinkModelFacet)expected, (TypeLinkModelFacet)actual);
		}
	}
	
	private void testTypeLinkModelFacet(TypeLinkModelFacet expected, TypeLinkModelFacet actual) {
		assertEquals(expected.getMetaClass().getName(), actual.getMetaClass().getName());
		testTypeModelFacet(expected, actual);
	}
	
	public void testGenParser() {
		GenParsers expected = expectedGenerator.getLabelParsers();
		GenParsers actual = actualGenerator.getLabelParsers();

		if (expected != null) {
			assertNotNull(actual);

			System.out.println(expected.getImplementations());
			System.out.println(actual.getImplementations());

			assertEquals(expected.getClassName(), actual.getClassName());
			assertEquals(expected.getImplPackageName(), actual.getImplPackageName());
			assertEquals(expected.getPackageName(), actual.getPackageName());
			assertEquals(expected.getProviderPriority().getLiteral(), actual.getProviderPriority().getLiteral());
			assertEquals(expected.isExtensibleViaService(), actual.isExtensibleViaService());

			assertEquals(expected.getImplementations().size(), actual.getImplementations().size());

			for (int i=0; i<expected.getImplementations().size(); i++) {
				GenParserImplementation exp = expected.getImplementations().get(i);
				GenParserImplementation act = actual.getImplementations().get(i);

				testGenParserImplementation(exp, act);
			}
		} else {
			assertNull(actual);
		}
	}

	private void testGenParserImplementation(GenParserImplementation expected, GenParserImplementation actual) {
		assertEquals(expected.eClass(), actual.eClass());

		assertEquals(expected.getUses().size(), actual.getUses().size());

		if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getExternalParser())) {
			testExternalParser((ExternalParser)expected, (ExternalParser)actual);
		} else if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getExpressionLabelParser())) {
			testExpressionLabelParser((ExpressionLabelParser)expected, (ExpressionLabelParser)actual);
		}
	}

	private void testExpressionLabelParser(ExpressionLabelParser expected, ExpressionLabelParser actual) {
		assertEquals(expected.getClassName(), actual.getClassName());

		assertEquals(expected.getExpressionContext().getName(), actual.getExpressionContext().getName());

		if (expected.getEditExpression() != null) {
			assertNotNull(actual.getEditExpression());

			ValueExpression exp = expected.getEditExpression();
			ValueExpression act = actual.getEditExpression();

			assertEquals(exp.eClass(), act.eClass());
			assertEquals(exp.getBody(), act.getBody());
			assertEquals(exp.getLangName(), act.getLangName());

			if (exp.getProvider() != null) {
				assertNotNull(act.getProvider());
			} else {
				assertNull(act.getProvider());
			}

			if (exp.eClass().equals(GMFGenPackage.eINSTANCE.getGenConstraint())) {

			}
		}
	}

	private void testExternalParser(ExternalParser expected, ExternalParser actual) {
		assertEquals(expected.getHint(), actual.getHint());
	}

	public void testPalette() {
		Palette expected = expectedGenerator.getDiagram().getPalette();
		Palette actual = actualGenerator.getDiagram().getPalette();
	
		assertNotNull("Expected Palette should not be null", expected);
		assertNotNull("Actual Palette should not be null", actual);
	
		assertEquals(expected.getFactoryClassName(), actual.getFactoryClassName());
		assertEquals(expected.isFlyout(), actual.isFlyout());
		assertEquals(expected.getPackageName(), actual.getPackageName());
	
		assertEquals(expected.getGroups().size(), actual.getGroups().size());
		for (int i=0; i<expected.getGroups().size(); i++) {
			ToolGroup exp = expected.getGroups().get(i);
			ToolGroup act = actual.getGroups().get(i);
	
			testToolGroup(exp, act);
		}
	}

	private void testToolGroup(ToolGroup expected, ToolGroup actual) {
		assertEquals(expected.getId(), actual.getId());
		assertEquals(expected.getDescription(), actual.getDescription());
		assertEquals(expected.getTitle(), actual.getTitle());
		assertEquals(expected.getLargeIconPath(), actual.getLargeIconPath());
		assertEquals(expected.getSmallIconPath(), actual.getSmallIconPath());
		assertEquals(expected.getCreateMethodName(), actual.getCreateMethodName());

		assertEquals(expected.isCollapse(), actual.isCollapse());
		assertEquals(expected.isStack(), actual.isStack());
		assertEquals(expected.isToolsOnly(), actual.isToolsOnly());

		assertEquals(expected.getEntries().size(), actual.getEntries().size());
		for (int i = 0; i < expected.getEntries().size(); i++) {
			ToolGroupItem exp = expected.getEntries().get(i);
			ToolGroupItem act = actual.getEntries().get(i);

			if (exp instanceof AbstractToolEntry) {
				testAbstractToolEntry((AbstractToolEntry)exp, (AbstractToolEntry)act);
			}
		}
	}

	private void testAbstractToolEntry(AbstractToolEntry expected, AbstractToolEntry actual) {
		assertEquals(expected.eClass(), actual.eClass());

		assertEquals(expected.getCreateMethodName(), actual.getCreateMethodName());
		assertEquals(expected.getId(), actual.getId());
		assertEquals(expected.getDescription(), actual.getDescription());
		assertEquals(expected.getTitle(), actual.getTitle());
		assertEquals(expected.getLargeIconPath(), actual.getLargeIconPath());
		assertEquals(expected.getSmallIconPath(), actual.getSmallIconPath());

		assertEquals(expected.isDefault(), actual.isDefault());
		assertEquals(expected.getQualifiedToolName(), actual.getQualifiedToolName());

		assertEquals(expected.getProperties().size(), actual.getProperties().size());
		for (int i=0; i<expected.getProperties().size(); i++) {
			Entry<String, String> exp = expected.getProperties().get(i);
			Entry<String, String> act = actual.getProperties().get(i);

			assertEquals(exp.getKey(), act.getKey());
			assertEquals(exp.getKey(), act.getValue());
		}

		if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getStandardEntry())) {
			testStandardEntry((StandardEntry) expected, (StandardEntry) actual);
		} else if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getToolEntry())) {
			testToolEntry((ToolEntry) expected, (ToolEntry) actual);
		}
	}

	private void testStandardEntry(StandardEntry expected, StandardEntry actual) {
		assertEquals(expected.getKind().getLiteral(), actual.getKind().getLiteral());
	}

	private void testToolEntry(ToolEntry expected, ToolEntry actual) {
		assertEquals(expected.getElements().size(), actual.getElements().size());
		for (int i=0; i<expected.getElements().size(); i++) {
			GenCommonBase exp = expected.getElements().get(i);
			GenCommonBase act = expected.getElements().get(i);

			assertEquals(exp.eClass(), act.eClass());
			assertEquals(exp.getVisualID(), act.getVisualID());
			assertEquals(exp.getUniqueIdentifier(), act.getUniqueIdentifier());
		}
		assertEquals(expected.getGenLinks().size(), actual.getGenLinks().size());
		for (int i=0; i<expected.getGenLinks().size(); i++) {
			GenLink exp = expected.getGenLinks().get(i);
			GenLink act = expected.getGenLinks().get(i);

			assertEquals(exp.eClass(), act.eClass());
			assertEquals(exp.getVisualID(), act.getVisualID());
			assertEquals(exp.getUniqueIdentifier(), act.getUniqueIdentifier());
		}
		assertEquals(expected.getGenNodes().size(), actual.getGenNodes().size());
		for (int i=0; i<expected.getGenNodes().size(); i++) {
			GenNode exp = expected.getGenNodes().get(i);
			GenNode act = expected.getGenNodes().get(i);

			assertEquals(exp.eClass(), act.eClass());
			assertEquals(exp.getVisualID(), act.getVisualID());
			assertEquals(exp.getUniqueIdentifier(), act.getUniqueIdentifier());
		}
	}

	public void testGenAuditRoot() {
		GenAuditRoot expected = expectedGenerator.getAudits();
		GenAuditRoot actual = actualGenerator.getAudits();

		testGenAuditContainers(expected.getCategories(), actual.getCategories());
	}

	public void testGenPreferencePages() {
		EList<GenPreferencePage> expected = expectedGenerator.getDiagram().getPreferencePages();
		EList<GenPreferencePage> actual = actualGenerator.getDiagram().getPreferencePages();

		assertEquals(expected.size(), actual.size());
		for (int i=0; i<expected.size(); i++) {
			GenPreferencePage exp = expected.get(i);
			GenPreferencePage act = actual.get(i);

			assertEquals(exp.eClass(), act.eClass());
			assertEquals(exp.getID(), act.getID());
			assertEquals(exp.getName(), act.getName());
			assertEquals(exp.getClassName(), act.getClassName());
			assertEquals(exp.getParentCategory(), act.getParentCategory());
			assertEquals(exp.getQualifiedClassName(), act.getQualifiedClassName());

			if (exp.eClass().equals(GMFGenPackage.eINSTANCE.getGenCustomPreferencePage())) {
				assertEquals((GenCustomPreferencePage)exp, (GenCustomPreferencePage)act);
			} else if (exp.eClass().equals(GMFGenPackage.eINSTANCE.getGenStandardPreferencePage())) {
				assertEquals((GenStandardPreferencePage)exp, (GenStandardPreferencePage)act);
			}
		}
	}

	private void assertEquals(GenCustomPreferencePage expected, GenCustomPreferencePage actual) {
		assertEquals(expected.isGenerateBoilerplate(), actual.isGenerateBoilerplate());
		assertEquals(expected.getQualifiedClassName(), actual.getQualifiedClassName());
	}

	private void assertEquals(GenStandardPreferencePage expected, GenStandardPreferencePage actual) {
		assertEquals(expected.getClassName(), actual.getClassName());
		assertEquals(expected.getKind().getLiteral(), actual.getKind().getLiteral());
	}

	protected void testGenAuditContainers(EList<GenAuditContainer> expected, EList<GenAuditContainer> actual) {
		assertEquals(expected.size(), actual.size());
		for (int i=0; i<expected.size(); i++) {
			GenAuditContainer exp = expected.get(i);
			GenAuditContainer act = actual.get(i);

			assertEquals(exp.getId(), act.getId());
			assertEquals(exp.getDescription(), act.getDescription());
			assertEquals(exp.getName(), act.getName());

			assertEquals(exp.getPath().size(), act.getPath().size());
		}
	}

	protected void testGenAuditRules(EList<GenAuditRule> expected, EList<GenAuditRule> actual) {
		assertEquals(expected.size(), actual.size());

		for (int i=0; i<expected.size(); i++) {
			GenAuditRule exp = expected.get(i);
			GenAuditRule act = actual.get(i);

			assertEquals(exp.getId(), act.getId());
			assertEquals(exp.getDescription(), act.getDescription());
			assertEquals(exp.getMessage(), act.getMessage());
			assertEquals(exp.getName(), act.getName());
			assertEquals(exp.isRequiresConstraintAdapter(), act.isRequiresConstraintAdapter());
			assertEquals(exp.getSeverity().getLiteral(), act.getSeverity().getLiteral());
			assertEquals(exp.isUseInLiveMode(), act.isUseInLiveMode());

			GenAuditable expAuditable = exp.getTarget();
			GenAuditable actAuditable = act.getTarget();

			assertEquals(expAuditable.eClass(), actAuditable.eClass());
			assertEquals(expAuditable.getTargetClassModelQualifiedName(), actAuditable.getTargetClassModelQualifiedName());
			assertEquals(expAuditable.getTargetClass(), actAuditable.getTargetClass());
			assertEquals(expAuditable.getContext(), actAuditable.getContext());

			if (expAuditable.eClass().equals(GMFGenPackage.eINSTANCE.getGenDomainAttributeTarget())) {
				assertEquals((GenDomainAttributeTarget) expAuditable, (GenDomainAttributeTarget) actAuditable);
			} else if (expAuditable.eClass().equals(GMFGenPackage.eINSTANCE.getGenDomainElementTarget())) {
				assertEquals((GenDomainElementTarget) expAuditable, (GenDomainElementTarget) actAuditable);
			} else if (expAuditable.eClass().equals(GMFGenPackage.eINSTANCE.getGenNotationElementTarget())) {
				assertEquals((GenNotationElementTarget) expAuditable, (GenNotationElementTarget) actAuditable);
			}
		}
	}

	private void assertEquals(GenDomainAttributeTarget expected, GenDomainAttributeTarget actual) {
		assertEquals(expected.isNullAsError(), actual.isNullAsError());
		assertEquals(expected.getAttribute(), actual.getAttribute());
	}

	private void assertEquals(GenDomainElementTarget expected, GenDomainElementTarget actual) {
		assertEquals(expected.getElement(), actual.getElement());
	}

	private void assertEquals(GenNotationElementTarget expected, GenNotationElementTarget actual) {
		assertEquals(expected.getElement(), actual.getElement());
	}

	protected void testBehaviours(EList<Behaviour> expected, EList<Behaviour> actual) {
		assertEquals(expected.size(), actual.size());

		for (int i=0; i<expected.size(); i++) {
			Behaviour exp = expected.get(i);
			Behaviour act = actual.get(i);

			assertEquals(exp.eClass(), act.eClass());
			assertEquals(exp.getEditPolicyQualifiedClassName(), act.getEditPolicyQualifiedClassName());
			assertEquals(exp.getSubject().getUniqueIdentifier(), act.getSubject().getUniqueIdentifier());

			if (exp.eClass().equals(GMFGenPackage.eINSTANCE.getOpenDiagramBehaviour())) {
				assertEquals((OpenDiagramBehaviour)exp, (OpenDiagramBehaviour)act);
			} else if (exp.eClass().equals(GMFGenPackage.eINSTANCE.getSharedBehaviour())) {
				assertEquals((SharedBehaviour)exp, (SharedBehaviour)act);
			}
		}
	}

	protected void assertEquals(OpenDiagramBehaviour expected, OpenDiagramBehaviour actual) {
		assertEquals(expected.getDiagramKind(), actual.getDiagramKind());
		assertEquals(expected.getEditorID(), actual.getEditorID());
		assertEquals(expected.getEditPolicyClassName(), actual.getEditPolicyClassName());
	}

	protected void assertEquals(SharedBehaviour expected, SharedBehaviour actual) {
		assertEquals(expected.getDelegate().getSubject().getUniqueIdentifier(), actual.getDelegate().getSubject().getUniqueIdentifier());
	}

	protected void testElementType(ElementType expected, ElementType actual) {
		if (expected == null) {
			assertNull(actual);
		} else {
			assertNotNull(actual);
	
			assertEquals(expected.eClass(), actual.eClass());
			assertEquals(expected.getDisplayName(), actual.getDisplayName());
			assertEquals(expected.getUniqueIdentifier(), actual.getUniqueIdentifier());
			assertEquals(expected.getDiagramElement().getUniqueIdentifier(), actual.getDiagramElement().getUniqueIdentifier());
		}
	}

	protected void testViewmap(Viewmap expected, Viewmap actual) {
		assertNotNull(expected);
		assertNotNull(actual);

		assertEquals(expected.eClass(), actual.eClass());
		assertEquals(expected.getLayoutType(), actual.getLayoutType());
		assertEquals(expected.getRequiredPluginIDs().size(), actual.getRequiredPluginIDs().size());

		for (int i=0; i<expected.getRequiredPluginIDs().size(); i++) {
			String exp = expected.getRequiredPluginIDs().get(i);
			String act = expected.getRequiredPluginIDs().get(i);

			assertEquals(exp, act);
		}
		List<String> actualPluginsIDs = actual.getRequiredPluginIDs();
		for (int i=0; i<expected.getRequiredPluginIDs().size(); i++) {
			String exp = expected.getRequiredPluginIDs().get(i);
			
			assertTrue(actualPluginsIDs.contains(exp));
		}
		EList<Attributes> expAttributes = expected.getAttributes();
		EList<Attributes> actAttributes = actual.getAttributes();
		assertEquals(expAttributes.size(), actAttributes.size());
		for (int j=0; j<expAttributes.size(); j++) {
			Attributes expAttr = expAttributes.get(j);
			Attributes actAttr = actAttributes.get(j);
			testAttributes(expAttr, actAttr);
		}

		if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getFigureViewmap())) {
			assertEquals((FigureViewmap)expected, (FigureViewmap)actual);
		} else if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getSnippetViewmap())) {
			assertEquals((SnippetViewmap)expected, (SnippetViewmap)actual);
		} else if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getInnerClassViewmap())) {
			assertEquals((InnerClassViewmap)expected, (InnerClassViewmap)actual);
		} else if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getParentAssignedViewmap())) {
			assertEquals((ParentAssignedViewmap)expected, (ParentAssignedViewmap)actual);
		} else if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getModeledViewmap())) {
			assertEquals((ModeledViewmap)expected, (ModeledViewmap)actual);
		}
	}

	protected void assertEquals(ModeledViewmap expected, ModeledViewmap actual) {
		assertEquals(expected.getFigureModel(), actual.getFigureModel());
	}

	protected void assertEquals(ParentAssignedViewmap expected, ParentAssignedViewmap actual) {
		assertEquals(expected.getFigureQualifiedClassName(), actual.getFigureQualifiedClassName());
		assertEquals(expected.getGetterName(), actual.getGetterName());
		assertEquals(expected.getSetterName(), actual.getSetterName());
	}

	protected void assertEquals(InnerClassViewmap expected, InnerClassViewmap actual) {
		assertEquals(expected.getClassBody(), actual.getClassBody());
		assertEquals(expected.getClassName(), actual.getClassName());
	}

	protected void assertEquals(SnippetViewmap expected, SnippetViewmap actual) {
		assertEquals(expected.getBody(), actual.getBody());
	}

	protected void assertEquals(FigureViewmap expected, FigureViewmap actual) {
		assertEquals(expected.getFigureQualifiedClassName(), actual.getFigureQualifiedClassName());
	}

	protected void testAttributes(Attributes expected, Attributes actual) {
		assertNotNull(expected);
		assertNotNull(actual);

		assertEquals(expected.eClass(), actual.eClass());

		if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getColorAttributes())) {
			assertEquals((ColorAttributes) expected, (ColorAttributes) actual);
		} else if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getStyleAttributes())) {
			assertEquals((StyleAttributes) expected, (StyleAttributes) actual);
		} else if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getResizeConstraints())) {
			assertEquals((ResizeConstraints) expected, (ResizeConstraints) actual);
		} else if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getDefaultSizeAttributes())) {
			assertEquals((DefaultSizeAttributes) expected, (DefaultSizeAttributes) actual);
		} else if (expected.eClass().equals(GMFGenPackage.eINSTANCE.getLabelOffsetAttributes())) {
			assertEquals((LabelOffsetAttributes) expected, (LabelOffsetAttributes) actual);
		} else {
			throw new IllegalArgumentException("EClass not found");
		}
	}

	protected void assertEquals(ColorAttributes expected, ColorAttributes actual) {
		assertEquals(expected.getBackgroundColor(), actual.getBackgroundColor());
		assertEquals(expected.getForegroundColor(), actual.getForegroundColor());
	}

	protected void assertEquals(StyleAttributes expected, StyleAttributes actual) {
		assertEquals(expected.isFixedBackground(), actual.isFixedBackground());
		assertEquals(expected.isFixedFont(), actual.isFixedFont());
		assertEquals(expected.isFixedForeground(), actual.isFixedForeground());
	}

	protected void assertEquals(ResizeConstraints expected, ResizeConstraints actual) {
		assertEquals(expected.getNonResizeHandles(), actual.getNonResizeHandles());
		assertEquals(expected.getResizeHandles(), actual.getResizeHandles());
		assertEquals(expected.getResizeHandleNames().size(), actual.getResizeHandleNames().size());
		for (int i=0; i<expected.getResizeHandleNames().size(); i++) {
			String exp = expected.getResizeHandleNames().get(i);
			String act = actual.getResizeHandleNames().get(i);

			assertEquals(exp, act);
		}
		assertEquals(expected.getNonResizeHandleNames().size(), actual.getNonResizeHandleNames().size());
		for (int i=0; i<expected.getNonResizeHandleNames().size(); i++) {
			String exp = expected.getNonResizeHandleNames().get(i);
			String act = actual.getNonResizeHandleNames().get(i);

			assertEquals(exp, act);
		}
	}

	protected void assertEquals(DefaultSizeAttributes expected, DefaultSizeAttributes actual) {
		assertEquals(expected.getHeight(), actual.getHeight());
		assertEquals(expected.getWidth(), actual.getWidth());
	}

	protected void assertEquals(LabelOffsetAttributes expected, LabelOffsetAttributes actual) {
		assertEquals(expected.getX(), actual.getX());
		assertEquals(expected.getY(), actual.getY());
	}

	private GenCompartment findCompartment(GenCompartment expected, EList<GenCompartment> compartments) {
		for (GenCompartment actual: compartments) {
			if (actual.getUniqueIdentifier().equals(expected.getUniqueIdentifier())) {
				return actual;
			}
		}
		return null;
	}

	protected IProject createProject() {
		String projectName = "TransformToGenModelOperationTest_" + String.valueOf(System.currentTimeMillis()); //$NON-NLS-1$
		IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
		assertFalse("Project with this name already present in the workspace: " + projectName, project.exists());
		try {
			project.create(new NullProgressMonitor());
			project.open(new NullProgressMonitor());
		} catch (CoreException e) {
			fail(e.getMessage());
		}
		assertTrue("Project was not created: " + projectName, project.exists());
		return project;
	}

	protected void deleteProject() throws CoreException {
		if (getProject() != null) {
			if (getProject().isOpen()) {
				getProject().close(new NullProgressMonitor());
			}
			if (getProject().exists()) {
				getProject().delete(true, new NullProgressMonitor());
			}
		}
	}

	protected IProject getProject() {
		return myProject;
	}
}