org.eclipse.fmc.blockdiagram.editor.tests/src/org/eclipse/fmc/FMCDiagramStateChecker.java

/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2013, 2013 SAP AG.
 * 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:
 *    SAP AG - initial API, implementation and documentation
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.fmc;

import static org.eclipse.fmc.FMCTestCase.assertSameSize;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.util.HashSet;
import java.util.Set;

import org.eclipse.fmc.blockdiagram.editor.algorithm.node.FMCNodeAlgorithm;
import org.eclipse.fmc.blockdiagram.editor.algorithm.node.FMCNodeAlgorithmFactory;
import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
import org.eclipse.graphiti.mm.pictograms.Anchor;
import org.eclipse.graphiti.mm.pictograms.CompositeConnection;
import org.eclipse.graphiti.mm.pictograms.Connection;
import org.eclipse.graphiti.mm.pictograms.ContainerShape;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.mm.pictograms.Shape;

public class FMCDiagramStateChecker {

	private FMCNodeAlgorithmFactory factory = FMCNodeAlgorithmFactory
			.getInstance();

	public void checkDiagramState(Diagram diagram) {
		checkNoAnchorsInDiagram(diagram);
		checkDiagramStateRecursively(diagram);
		checkConnectionOrphans(diagram);
	}

	private void checkDiagramStateRecursively(ContainerShape container) {
		for (Shape shape : container.getChildren()) {
			if (shape instanceof ContainerShape) {
				ContainerShape childContainer = (ContainerShape) shape;
				FMCNodeAlgorithm node = factory.getShape(shape);
				if (node != null) {
					if (node.isMultipleInstances(childContainer)) {
						checkMultiInstanceShapeState(childContainer, node);
					}
				}
				if (!childContainer.getGraphicsAlgorithm().isSetFilled()
						&& !childContainer.getGraphicsAlgorithm()
								.isSetLineVisible()) {
					for (Anchor anchor : childContainer.getAnchors()) {
						if (anchor.getIncomingConnections().isEmpty()
								&& anchor.getOutgoingConnections().isEmpty())
							fail("Invisible shape without connection detected");
					}

				}
				checkDiagramStateRecursively(childContainer);
			} else {

			}
		}
	}

	private void checkConnectionOrphans(Diagram diagram) {
		Set<CompositeConnection> composites = new HashSet<CompositeConnection>();
		for (Connection con : diagram.getConnections()) {
			if (con instanceof CompositeConnection) {
				composites.add((CompositeConnection) con);
			}
		}

		for (Connection con : diagram.getConnections()) {
			if (!isChildOfComposite(composites, con)) {
				assertNotNull("Orphaned connection with no start anchor",
						con.getStart());
				assertNotNull("Orphaned connection with no end anchor",
						con.getEnd());
				assertNotNull("Orphaned connection with no start anchor", con
						.getStart().getParent());
				assertNotNull("Orphaned connection with no end anchor", con
						.getEnd().getParent());
				assertFalse(con.getStart().getParent() == diagram);
				assertFalse(con.getEnd().getParent() == diagram);
			}
		}
	}

	private boolean isChildOfComposite(Set<CompositeConnection> composites,
			Connection child) {
		for (CompositeConnection comp : composites) {
			for (Connection con : comp.getChildren()) {
				if (con == child)
					return true;
			}
		}
		return false;
	}

	private void checkMultiInstanceShapeState(ContainerShape childContainer,
			FMCNodeAlgorithm node) {
		GraphicsAlgorithm multiInstanceChildMain = node.getMultiInstanceChild(
				childContainer, true);
		GraphicsAlgorithm multiInstanceChildSecond = node
				.getMultiInstanceChild(childContainer, false);
		assertNotNull(multiInstanceChildMain);
		assertNotNull(multiInstanceChildSecond);
		assertEquals(multiInstanceChildMain.getClass(),
				multiInstanceChildSecond.getClass());
		assertSameSize(multiInstanceChildMain, multiInstanceChildSecond);
		assertEquals(multiInstanceChildMain.getX(),
				multiInstanceChildSecond.getX() + 5);
		assertEquals(multiInstanceChildMain.getY() + 5,
				multiInstanceChildSecond.getY());
	}

	private void checkNoAnchorsInDiagram(Diagram diagram) {
		assertTrue(
				"State of diagram not valid: There are anchors in the diagram.",
				diagram.getAnchors().isEmpty());
	}

}