tests/org.eclipse.graphiti.tests/src/org/eclipse/graphiti/tests/cases/CreateServiceTest.java

/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2005, 2010 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
 *    mwenz - Bug 331715: Support for rectangular grids in diagrams
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.graphiti.tests.cases;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;

import java.util.List;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.resource.impl.ResourceImpl;
import org.eclipse.graphiti.mm.algorithms.Ellipse;
import org.eclipse.graphiti.mm.algorithms.Image;
import org.eclipse.graphiti.mm.algorithms.MultiText;
import org.eclipse.graphiti.mm.algorithms.PlatformGraphicsAlgorithm;
import org.eclipse.graphiti.mm.algorithms.Polygon;
import org.eclipse.graphiti.mm.algorithms.Polyline;
import org.eclipse.graphiti.mm.algorithms.Rectangle;
import org.eclipse.graphiti.mm.algorithms.RoundedRectangle;
import org.eclipse.graphiti.mm.algorithms.Text;
import org.eclipse.graphiti.mm.algorithms.styles.Point;
import org.eclipse.graphiti.mm.algorithms.styles.Style;
import org.eclipse.graphiti.mm.pictograms.Diagram;
import org.eclipse.graphiti.mm.pictograms.Shape;
import org.eclipse.graphiti.services.Graphiti;
import org.eclipse.graphiti.services.ICreateService;
import org.eclipse.graphiti.tests.GFAbstractCreateTestCase;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class CreateServiceTest extends GFAbstractCreateTestCase {

	public static ICreateService crs = Graphiti.getCreateService();
	private Diagram d;
	private Shape s1;

	@BeforeClass
	public static void prepareClass() {
	}

	@Before
	public void initializeTest() {
		d = Graphiti.getPeCreateService().createDiagram("tutorial", "test", true);
		assertNotNull(d);
		s1 = Graphiti.getPeCreateService().createShape(d, true);
		s1.setGraphicsAlgorithm(Graphiti.getGaCreateService().createRectangle(d));
		assertNotNull(s1);
		ResourceImpl resource = new ResourceImpl();
		resource.getContents().add(d);
	}

	@Test
	public void createDefaultMultiText() {
		MultiText multiText = crs.createDefaultMultiText(d, s1);
		assertNotNull(multiText);
		assertEquals(DEFAULT_FONT, multiText.getFont().getName());
		checkTextDefaults(multiText, "");
	}

	@Test
	public void createDefaultMultiText2() {
		MultiText multiText = crs.createDefaultMultiText(d, s1, VALUE);
		assertNotNull(multiText);
		assertEquals(DEFAULT_FONT, multiText.getFont().getName());
		checkTextDefaults(multiText, VALUE);
	}

	@Test
	public void createDefaultText() {
		Text text = crs.createDefaultText(d, s1);
		assertNotNull(text);
		assertEquals(DEFAULT_FONT, text.getFont().getName());
		checkTextDefaults(text, "");
	}

	@Test
	public void createDefaultText2() {
		Text text = crs.createDefaultText(d, s1, VALUE);
		assertNotNull(text);
		assertEquals(DEFAULT_FONT, text.getFont().getName());
		checkTextDefaults(text, VALUE);
	}

	@Test
	public void createEllipse() {
		Ellipse ellipse = crs.createEllipse(s1);
		assertNotNull(ellipse);
		checkGraphicsAlgorithmDefaults(ellipse);
	}


	@Test
	public void createImage() {
		Image im = crs.createImage(d, VALUE);
		checkGraphicsAlgorithmDefaults(im);
		checkImageDefaults(im);
	}

	@Test
	public void createInvisibleRectangle() {
		Rectangle invisibleRect = crs.createInvisibleRectangle(s1);
		assertFalse(invisibleRect.getLineVisible());
	}

	@Test
	public void createMultiText() {
		MultiText multiText = crs.createMultiText(s1);
		assertNotNull(multiText);
		assertNull(multiText.getFont());
		checkTextDefaults(multiText, "");
	}

	@Test
	public void createMultiText2() {
		MultiText multiText = crs.createMultiText(s1, VALUE);
		assertNotNull(multiText);
		assertNull(multiText.getFont());
		checkTextDefaults(multiText, VALUE);
	}

	@Test
	public void createPlatformGa() {
		PlatformGraphicsAlgorithm pGa = crs.createPlatformGraphicsAlgorithm(s1, VALUE);
		assertEquals(s1, pGa.eContainer());
		assertEquals(VALUE, pGa.getId());
	}

	@Test
	public void createPoint() {
		Point point = crs.createPoint(0, 1);
		assertEquals(0, point.getX());
		assertEquals(1, point.getY());
		point = crs.createPoint(1, 0, 2, 3);
		assertEquals(1, point.getX());
		assertEquals(0, point.getY());
		assertEquals(2, point.getBefore());
		assertEquals(3, point.getAfter());
	}

	@Test
	public void createPointList() {
		List<Point> points = crs.createPointList(new int[] { 1, 2, 3, 4 });
		Point p1 = points.get(0);
		assertEquals(1, p1.getX());
		assertEquals(2, p1.getY());
		Point p2 = points.get(1);
		assertEquals(3, p2.getX());
		assertEquals(4, p2.getY());
	}

	@Test
	public void createPointList2() {
		List<Point> points = crs.createPointList(new int[] { 1, 2, 3, 4 }, new int[] { 5, 6, 7, 8 });
		Point p1 = points.get(0);
		assertEquals(1, p1.getX());
		assertEquals(2, p1.getY());
		assertEquals(5, p1.getBefore());
		assertEquals(6, p1.getAfter());
		Point p2 = points.get(1);
		assertEquals(3, p2.getX());
		assertEquals(4, p2.getY());
		assertEquals(7, p2.getBefore());
		assertEquals(8, p2.getAfter());
	}

	@Test
	public void createPolygon() {
		Polygon polygon = crs.createPolygon(s1);
		assertEquals(polygon, s1.getGraphicsAlgorithm());
		checkGraphicsAlgorithmDefaults(polygon);
	}

	@Test
	public void createPolygon2() {
		List<Point> points = crs.createPointList(new int[] { 1, 2, 3, 4 });
		Polygon polygon = crs.createPolygon(s1, points);
		assertEquals(polygon, s1.getGraphicsAlgorithm());
		checkGraphicsAlgorithmDefaults(polygon);
		EList<Point> points2 = polygon.getPoints();
		assertEquals(points, points2);
	}

	@Test
	public void createPolygon3() {
		int[] points = new int[] { 1, 2, 3, 4 };
		Polygon polygon = crs.createPolygon(s1, points);
		assertEquals(polygon, s1.getGraphicsAlgorithm());
		checkGraphicsAlgorithmDefaults(polygon);
		EList<Point> points2 = polygon.getPoints();
		assertEquals(1, points2.get(0).getX());
		assertEquals(2, points2.get(0).getY());
		assertEquals(3, points2.get(1).getX());
		assertEquals(4, points2.get(1).getY());
		int[] beforeAfter = new int[] { 5, 6, 7, 8 };
		polygon = crs.createPolygon(s1, points, beforeAfter);
		checkGraphicsAlgorithmDefaults(polygon);
		points2 = polygon.getPoints();
		assertEquals(1, points2.get(0).getX());
		assertEquals(2, points2.get(0).getY());
		assertEquals(3, points2.get(1).getX());
		assertEquals(4, points2.get(1).getY());
		assertEquals(5, points2.get(0).getBefore());
		assertEquals(6, points2.get(0).getAfter());
		assertEquals(7, points2.get(1).getBefore());
		assertEquals(8, points2.get(1).getAfter());
	}

	@Test
	public void createPolyline() {
		Polyline polyline = crs.createPolyline(s1);
		assertEquals(polyline, s1.getGraphicsAlgorithm());
		checkGraphicsAlgorithmDefaults(polyline);
	}

	@Test
	public void createPolyline2() {
		List<Point> points = crs.createPointList(new int[] { 1, 2, 3, 4 });
		Polyline polyline = crs.createPolyline(s1, points);
		assertEquals(polyline, s1.getGraphicsAlgorithm());
		checkGraphicsAlgorithmDefaults(polyline);
		EList<Point> points2 = polyline.getPoints();
		assertEquals(points, points2);
	}

	@Test
	public void createPolyline3() {
		int[] points = new int[] { 1, 2, 3, 4 };
		Polyline polyline = crs.createPolyline(s1, points);
		assertEquals(polyline, s1.getGraphicsAlgorithm());
		checkGraphicsAlgorithmDefaults(polyline);
		EList<Point> points2 = polyline.getPoints();
		assertEquals(1, points2.get(0).getX());
		assertEquals(2, points2.get(0).getY());
		assertEquals(3, points2.get(1).getX());
		assertEquals(4, points2.get(1).getY());
		int[] beforeAfter = new int[] { 5, 6, 7, 8 };
		polyline = crs.createPolyline(s1, points, beforeAfter);
		checkGraphicsAlgorithmDefaults(polyline);
		points2 = polyline.getPoints();
		assertEquals(1, points2.get(0).getX());
		assertEquals(2, points2.get(0).getY());
		assertEquals(3, points2.get(1).getX());
		assertEquals(4, points2.get(1).getY());
		assertEquals(5, points2.get(0).getBefore());
		assertEquals(6, points2.get(0).getAfter());
		assertEquals(7, points2.get(1).getBefore());
		assertEquals(8, points2.get(1).getAfter());
	}

	@Test
	public void createRectangle() {
		Rectangle rect = crs.createRectangle(s1);
		assertEquals(rect, s1.getGraphicsAlgorithm());
		checkGraphicsAlgorithmDefaults(rect);
	}

	@Test
	public void createRoundedRectangle() {
		RoundedRectangle rect = crs.createRoundedRectangle(s1, 5, 6);
		assertEquals(rect, s1.getGraphicsAlgorithm());
		checkGraphicsAlgorithmDefaults(rect);
		assertEquals(5, rect.getCornerWidth());
		assertEquals(6, rect.getCornerHeight());
	}

	@Test
	public void createStyle() {
		Style style = crs.createStyle(d, VALUE);
		assertEquals(VALUE, style.getId());
		assertEquals(1, d.getStyles().size());
	}

	@Test
	public void createDiagram() {
		Diagram d0 = Graphiti.getCreateService().createDiagram("tutorial", "D0", 0, true);
		assertNotNull(d0);
		assertEquals("gridUnit must be 0, was: " + d0.getGridUnit(), 0, d0.getGridUnit());
		assertEquals("verticalGridUnit must be -1, was: " + d0.getGridUnit(), -1, d0.getVerticalGridUnit());

		Diagram d1 = Graphiti.getCreateService().createDiagram("tutorial", "D1", true);
		assertNotNull(d1);
		assertEquals("gridUnit must be 10 when not set explicitly, was: " + d1.getGridUnit(), 10, d1.getGridUnit());
		assertEquals("verticalGridUnit must be -1 when not set explicitly set, was: " + d1.getGridUnit(), -1, d1.getVerticalGridUnit());

		Diagram d2 = Graphiti.getCreateService().createDiagram("tutorial", "D2", 20, true);
		assertNotNull(d2);
		assertEquals("gridUnit must be set, was: " + d2.getGridUnit(), 20, d2.getGridUnit());
		assertEquals("verticalGridUnit must be -1 when not set explicitly set, was: " + d2.getVerticalGridUnit(), -1,
				d2.getVerticalGridUnit());

		Diagram d3 = Graphiti.getCreateService().createDiagram("tutorial", "D3", 20, 10, true);
		assertNotNull(d3);
		assertEquals("gridUnit must be set, was: " + d3.getGridUnit(), 20, d3.getGridUnit());
		assertEquals("verticalGridUnit must be set, was: " + d3.getVerticalGridUnit(), 10, d3.getVerticalGridUnit());
	}

}