tests/org.eclipse.draw2d.test/src/org/eclipse/draw2d/test/ScalablePolygonShapeTest.java

/*******************************************************************************
 * Copyright (c) 2008, 2010 IBM Corporation 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:
 *    Alexander Shatalin (Borland) - initial API and implementation
 *******************************************************************************/
package org.eclipse.draw2d.test;

import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.SWTGraphics;
import org.eclipse.draw2d.ScalablePolygonShape;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.widgets.Display;

public class ScalablePolygonShapeTest extends AbstractFixtureTestCase {

	private static final int RECTANGLE_START = 1;

	private static final int RECTANGLE_END = 5;

	private static final PointList RECTANGLE_POINTS = new PointList(new int[] {
			RECTANGLE_START, RECTANGLE_START, RECTANGLE_END, RECTANGLE_START,
			RECTANGLE_END, RECTANGLE_END, RECTANGLE_START, RECTANGLE_END });

	private static final int LINE_WIDTH = 2;

	private static final Rectangle RECTANGLE_BOUNDS = new Rectangle(0, 0,
			RECTANGLE_END + LINE_WIDTH, RECTANGLE_END + LINE_WIDTH);

	private static final Rectangle RECTANGLE_DOUBLED_BOUNDS = new Rectangle(0,
			0, RECTANGLE_END * 2 + LINE_WIDTH, RECTANGLE_END * 2 + LINE_WIDTH);

	public void testScaledPointsEquality() {
		ScalablePolygonShape scalablePolygon = new ScalablePolygonShape();
		scalablePolygon.setPoints(RECTANGLE_POINTS);
		scalablePolygon.setBounds(RECTANGLE_BOUNDS);
		scalablePolygon.setLineWidth(LINE_WIDTH);
		PointList scaledPoints = scalablePolygon.getScaledPoints();
		checkScaledPointsNotChanged(scalablePolygon, scaledPoints);
	}

	public void testPointsUnchangedOnScaling() {
		ScalablePolygonShape scalablePolygon = new ScalablePolygonShape();
		PointList points = RECTANGLE_POINTS.getCopy();
		scalablePolygon.setPoints(points);
		scalablePolygon.setBounds(RECTANGLE_BOUNDS);
		scalablePolygon.getScaledPoints();
		scalablePolygon.setBounds(RECTANGLE_DOUBLED_BOUNDS);
		scalablePolygon.getScaledPoints();
		assertEquals(points, scalablePolygon.getPoints());
		checkEquals(RECTANGLE_POINTS, points);
	}

	public void testSmallBounds() {
		ScalablePolygonShape scalablePolygon = new ScalablePolygonShape();
		scalablePolygon.setPoints(RECTANGLE_POINTS);
		scalablePolygon.setLineWidth(LINE_WIDTH);
		scalablePolygon.setBounds(new Rectangle(0, 0, 0, 0));
		int[] scaledPoints = scalablePolygon.getScaledPoints().toIntArray();
		for (int i = 0; i < scaledPoints.length;) {
			assertEquals(LINE_WIDTH / 2, scaledPoints[i++]);
		}

		// width < lineWidth
		scalablePolygon.setBounds(new Rectangle(0, 0, 1, 100));
		scaledPoints = scalablePolygon.getScaledPoints().toIntArray();
		for (int i = 0; i < scaledPoints.length; i++) {
			assertEquals(LINE_WIDTH / 2, scaledPoints[i++]);
		}

		// height < lineWidth
		scalablePolygon.setBounds(new Rectangle(0, 0, 100, 1));
		scaledPoints = scalablePolygon.getScaledPoints().toIntArray();
		for (int i = 1; i < scaledPoints.length; i++) {
			assertEquals(LINE_WIDTH / 2, scaledPoints[i++]);
		}
	}

	public void testScaledPointsUpdateOnPointsChanging() {
		ScalablePolygonShape scalablePolygon = new ScalablePolygonShape();
		scalablePolygon.setBounds(RECTANGLE_BOUNDS);
		scalablePolygon.setLineWidth(LINE_WIDTH);
		PointList scaledPoints = scalablePolygon.getScaledPoints();
		assertEquals(0, scaledPoints.size());

		scalablePolygon.addPoint(new Point(0, 0));
		scaledPoints = checkScaledPointsChanged(scalablePolygon, scaledPoints,
				1);

		scalablePolygon.removeAllPoints();
		scaledPoints = checkScaledPointsChanged(scalablePolygon, scaledPoints,
				0);

		scalablePolygon.setPoints(RECTANGLE_POINTS.getCopy());
		scaledPoints = checkScaledPointsChanged(scalablePolygon, scaledPoints,
				RECTANGLE_POINTS.size());

		scalablePolygon.setStart(new Point(2, 2));
		scaledPoints = checkScaledPointsChanged(scalablePolygon, scaledPoints,
				scaledPoints.size());

		scalablePolygon.setEnd(new Point(2, 5));
		scaledPoints = checkScaledPointsChanged(scalablePolygon, scaledPoints,
				scaledPoints.size());

		scalablePolygon.setPoint(new Point(5, 2), 1);
		scaledPoints = checkScaledPointsChanged(scalablePolygon, scaledPoints,
				scaledPoints.size());

		scalablePolygon.insertPoint(new Point(3, 4), 1);
		scaledPoints = checkScaledPointsChanged(scalablePolygon, scaledPoints,
				scaledPoints.size() + 1);

		scalablePolygon.removePoint(1);
		scaledPoints = checkScaledPointsChanged(scalablePolygon, scaledPoints,
				scaledPoints.size() - 1);
	}

	public void testScaledPointsUpdateOnBoundsChanging() {
		ScalablePolygonShape scalablePolygon = new ScalablePolygonShape();
		scalablePolygon.setPoints(RECTANGLE_POINTS);
		scalablePolygon.setBounds(RECTANGLE_BOUNDS);
		PointList scaledPoints = scalablePolygon.getScaledPoints();

		Rectangle bounds = RECTANGLE_BOUNDS.getCopy();
		scalablePolygon.setBounds(bounds.resize(10, 10));
		scaledPoints = checkScaledPointsChanged(scalablePolygon, scaledPoints,
				scaledPoints.size());

		// Size of the figure is the same, so scaledPoints should not be
		// changed.
		scalablePolygon.setBounds(bounds.translate(10, 10));
		checkScaledPointsNotChanged(scalablePolygon, scaledPoints);
	}

	public void testScaledPointsUpdateOnSetLineWidth() {
		ScalablePolygonShape scalablePolygon = new ScalablePolygonShape();
		scalablePolygon.setLineWidth(LINE_WIDTH);
		scalablePolygon.setPoints(RECTANGLE_POINTS);
		PointList scaledPoints = scalablePolygon.getScaledPoints();

		scalablePolygon.setLineWidth(LINE_WIDTH * 2);
		checkScaledPointsChanged(scalablePolygon, scaledPoints,
				scaledPoints.size());
	}

	public void testScaling() {
		ScalablePolygonShape scalablePolygon = new ScalablePolygonShape();
		scalablePolygon.setPoints(RECTANGLE_POINTS);
		scalablePolygon.setLineWidth(LINE_WIDTH);
		scalablePolygon.setBounds(RECTANGLE_DOUBLED_BOUNDS);
		checkScaledPointsNotChanged(scalablePolygon, new PointList(new int[] {
				3, 3, 11, 3, 11, 11, 3, 11 }));
	}

	public void off_testContainsPoints() {
		ScalablePolygonShape scalablePolygon = new ScalablePolygonShape();
		scalablePolygon.setPoints(RECTANGLE_POINTS);
		scalablePolygon.setLineWidth(1);
		scalablePolygon.setBounds(RECTANGLE_DOUBLED_BOUNDS);
		scalablePolygon.setOutline(true);
		scalablePolygon.setFill(true);
		scalablePolygon.setBackgroundColor(ColorConstants.black());
		scalablePolygon.setForegroundColor(ColorConstants.black());

		Display display = Display.getDefault();
		int imageSize = RECTANGLE_END * 3;
		Image image = new Image(display, imageSize, imageSize);
		GC gc = new GC(image.getDevice());
		// Filling initial image with white color
		gc.setBackground(ColorConstants.white());
		gc.setForeground(ColorConstants.white());
		gc.fillRectangle(0, 0, imageSize, imageSize);
		gc.drawRectangle(0, 0, imageSize, imageSize);

		gc.setBackground(ColorConstants.black());
		gc.setForeground(ColorConstants.black());
		SWTGraphics graphics = new SWTGraphics(gc);
		scalablePolygon.paint(graphics);
		graphics.dispose();
		gc.dispose();
		ImageData imageData = image.getImageData();
		for (int x = 0; x < imageSize; x++) {
			for (int y = 0; y < imageSize; y++) {
				boolean isPolygonPoint = imageData.getPixel(x, y) == 0;
				assertTrue(
						"Point (" + x + "," + y + ") is"
								+ (isPolygonPoint ? " " : " not ")
								+ "a point of polygon",
						scalablePolygon.containsPoint(new Point(x, y)) == isPolygonPoint);
			}
		}
	}

	private PointList checkScaledPointsChanged(
			ScalablePolygonShape scalablePolygon, PointList oldScaledPoints,
			int expectedSize) {
		PointList newScaledPoints = scalablePolygon.getScaledPoints();
		checkNotEquals(oldScaledPoints, newScaledPoints);
		assertEquals(expectedSize, newScaledPoints.size());
		return newScaledPoints;
	}

	private void checkNotEquals(PointList original, PointList modified) {
		if (original.size() != modified.size()) {
			return;
		}
		int[] originalIntArray = original.toIntArray();
		int[] modifiedIntArray = modified.toIntArray();
		for (int i = 0; i < modifiedIntArray.length; i++) {
			if (originalIntArray[i] != modifiedIntArray[i]) {
				return;
			}
		}
		fail("Passed point lists are equals");
	}

	private PointList checkScaledPointsNotChanged(
			ScalablePolygonShape scalablePolygon, PointList oldScaledPoints) {
		PointList newScaledPoints = scalablePolygon.getScaledPoints();
		checkEquals(oldScaledPoints, newScaledPoints);
		return newScaledPoints;
	}

	private void checkEquals(PointList original, PointList modified) {
		if (original.size() != modified.size()) {
			fail("Passed point lists are not equals");
		}
		int[] originalIntArray = original.toIntArray();
		int[] modifiedIntArray = modified.toIntArray();
		for (int i = 0; i < modifiedIntArray.length; i++) {
			if (originalIntArray[i] != modifiedIntArray[i]) {
				fail("Passed point lists are not equals");
			}
		}
	}

}