LineSegTest.java

/******************************************************************************
 * Copyright (c) 2003, 2006 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:
 *    IBM Corporation - initial API and implementation 
 ****************************************************************************/

package org.eclipse.gmf.tests.runtime.draw2d.ui;

import junit.framework.TestCase;

import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.draw2d.geometry.Rectangle;

import org.eclipse.gmf.runtime.draw2d.ui.geometry.LineSeg;
import org.eclipse.gmf.runtime.draw2d.ui.geometry.PointListUtilities;


/**
 * @author jschofie
 *
 * This test case is intended to test the LineSeg Class functionality
 */
public class LineSegTest extends TestCase {

	private LineSeg lineSeg;
	private LineSeg verticalLine;
	private LineSeg horizontalLine;

	private Point origin;
	private Point terminus;
	
	/* (non-Javadoc)
	 * @see junit.framework.TestCase#setUp()
	 */
	protected void setUp() throws Exception {
		super.setUp();
		
		origin = new Point( 5, 5 );
		terminus = new Point( 10, 10 );
		
		lineSeg = new LineSeg( origin, terminus );
		
		verticalLine = new LineSeg( new Point( 0, 5 ), new Point( 0, 105 ) );
		horizontalLine = new LineSeg( new Point( 0, 5 ), new Point( 100, 5 ) );
	}
	
	/*
	 * test the equals method
	 */
	public void testEqualsObject() {
		
		LineSeg seg1 = new LineSeg( new Point( 0, 0 ), new Point( 10, 10 ) );
		LineSeg seg2 = new LineSeg( new Point( 1, 1 ), new Point( 9, 9 ) );
		LineSeg seg3 = new LineSeg( new Point( 0, 0 ), new Point( 5, 5 ) );
		LineSeg seg4 = new LineSeg( new Point( 0, 0 ), new Point( 10, 10 ) );

		// Both line segment points are not equal
		assertFalse( seg1.equals( seg2 ) );
		
		// The origin points are equal but the ends are not
		assertFalse( seg1.equals( seg3 ) );
		
		// Both the origin and end points are equal
		assertTrue( seg1.equals( seg4 ) );
	}

	public void testGetOrigin() {
		assertEquals( origin, lineSeg.getOrigin() );
	}

	public void testGetTerminus() {
		assertEquals( terminus, lineSeg.getTerminus() );
	}

	public void testSetOrigin() {
		Point p1 = new Point( -5, -5 );
		
		lineSeg.setOrigin( p1 );
		assertEquals( p1, lineSeg.getOrigin() );
	}

	public void testSetTerminus() {
		Point p1 = new Point( -5, -5 );
		
		lineSeg.setTerminus( p1 );
		assertEquals( p1, lineSeg.getTerminus() );
	}

	public void testGetSupremum() {	
		assertEquals( terminus.x, lineSeg.getSupremum().x );
		assertEquals( terminus.y, lineSeg.getSupremum().y );
	}

	public void testGetInfimum() {
		assertEquals( origin.x, lineSeg.getInfimum().x );
		assertEquals( origin.y, lineSeg.getInfimum().y );
	}

	public void testIsHorizontal() {
		assertFalse( "verticalLine shouldn't be horizontal", verticalLine.isHorizontal() ); //$NON-NLS-1$
		assertTrue( "horizontalLine should be horizontal", horizontalLine.isHorizontal() ); //$NON-NLS-1$
	}

	public void testIsVertical() {
		assertTrue( "verticalLine should be vertical", verticalLine.isVertical() ); //$NON-NLS-1$
		assertFalse( "horizontalLine shouldn't be vertical", horizontalLine.isVertical() ); //$NON-NLS-1$
	}

	public void testSlope() {
	
		// Line is vertical
		assertTrue( "The line should be vertical", 9999 == verticalLine.slope() ); //$NON-NLS-1$

		// Line is horizontal
		assertTrue( "The line should be horizontal", 0.0 == horizontalLine.slope() ); //$NON-NLS-1$
	}

	public void testPerpSlope() {
	
		// Line is vertical
		assertEquals( "Perp Slope of a vertical line should be horizontal", 0, (int)verticalLine.perpSlope() ); //$NON-NLS-1$

		// Line is horizontal
		assertEquals( "Perp slope of a horizontal line should be vertical", 9999, (int)horizontalLine.perpSlope() ); //$NON-NLS-1$
	}

	public void testLength() {
		
		// Compute length of the vertical line
		assertEquals( "Vertical line seg length is not correct", 100, (int)verticalLine.length() ); //$NON-NLS-1$
		
		// Compute the length of the horizontal line
		assertEquals( "Horizontal line seg length is not correct", 100, (int)horizontalLine.length() ); //$NON-NLS-1$
	}

	public void testContainsPoint() {

		Point isContained  = new Point( 6, 6 );
		Point notContained = new Point( 3, 3 );
		
		assertTrue( lineSeg.containsPoint( isContained, 0 ) );
		assertFalse( lineSeg.containsPoint( notContained, 0 ) );
	}

	public void testDistanceAlong() {

		// Test nominal case
		assertEquals( "The distance has been incorrectly computed", 0, (int)lineSeg.distanceAlong( new Point( 5, 5 ) ) ); //$NON-NLS-1$
	
		// Test divide by zero
		Point p2 = new Point( 10, 10 );
		LineSeg seg2 = new LineSeg( p2, p2 );
		assertEquals( -1, (int)seg2.distanceAlong( new Point( 2, 2 ) ) );
	}

//	public void testIntersect() {
//	}
//
//	public void testDistanceToPoint() {
//	}
//
//	public void testPerpIntersect() {
//	}
//
//	public void testProjection() {
//	}
//
//	public void testPositionRelativeTo() {
//	}
//
//	public void testLocatePoint() {
//	}
//
//	public void testPointOn() {
//	}
//
//	public void testGetTrigValues() {
//	}
//
//	public void testGetParallelLineSegThroughPoint() {
//	}
	
	public void testLineEquation() {
		// Normal case
		Point p1 = new Point(1, 0);
		Point p2 = new Point(2, 1);
		LineSeg line = new LineSeg(p1,p2);
		double[] equation = line.getEquation();
		assertTrue("Equation is incomplete", equation.length == 3); //$NON-NLS-1$
		assertTrue("Coefficient 'a' is not correct", equation[0] == -1); //$NON-NLS-1$
		assertTrue("Coefficient 'b' is not correct", equation[1] == 1); //$NON-NLS-1$
		assertTrue("Coefficient 'c' is not correct", equation[2] == -1); //$NON-NLS-1$
	}

	public void testFindLineIntersections() {
		final PointList points = new PointList();
		points.addPoint(new Point(0, 10));
		points.addPoint(new Point(10, 0));
		points.addPoint(new Point(0, -10));
		points.addPoint(new Point(-10, 0));
		points.addPoint(new Point(0, 10));

		// Nominal case, i.e. 2 intersection points
		Point p1 = new Point(-20, 20);
		Point p2 = new Point(30, -30);
		LineSeg line = new LineSeg(p1,p2);
		PointList intersections = line.getLineIntersectionsWithLineSegs(points);
		assertTrue(
			"Line passing through " + p1 + " and " + p2 + "must have exactly 2 intersections with the figure", intersections.size() == 2); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		Point first = PointListUtilities.pickClosestPoint(intersections, p2);
		assertTrue(
			"This is not the closest intersection to " + p2, first.x == 5 && first.y == -5); //$NON-NLS-1$
		Point second = PointListUtilities.pickFarestPoint(intersections, p2);
		assertTrue(
			"This is not the farest intersection to " + p2, second.x == -5 && second.y == 5); //$NON-NLS-1$

		// 1 intersection point
		p1 = new Point(10, 10);
		p2 = new Point(10, -10);
		line = new LineSeg(p1,p2);
		intersections = line.getLineIntersectionsWithLineSegs(points);
		assertTrue(
			"Line passing through " + p1 + " and " + p2 + "must have exactly 1 intersections with the figure", intersections.size() == 2); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		first = PointListUtilities.pickClosestPoint(intersections, p2);
		second = PointListUtilities.pickFarestPoint(intersections, p2);
		assertTrue(second.x == first.x && second.y == first.y); 
		assertTrue(
			"Incorrect value for intersection point", first.x == 10 && first.y == 0); //$NON-NLS-1$

		// 0 intersection points
		p1 = new Point(20, 20);
		p2 = new Point(-10, 10);
		line = new LineSeg(p1,p2);
		intersections = line.getLineIntersectionsWithLineSegs(points);
		assertTrue(
			"Line passing through " + p1 + " and " + p2 + "must have no intersections with the figure", intersections.size() == 0); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		// Infinite number of intersections => must result in the two points
		// (ends of the linesegment
		// that lies on the line that passes through p1 and p2)
		p1 = new Point(20, -10);
		p2 = new Point(-10, 20);
		line = new LineSeg(p1,p2);
		intersections = line.getLineIntersectionsWithLineSegs(points);
		assertTrue(
			"Line passing through " + p1 + " and " + p2 + "must have exactly 2 intersections with the figure", intersections.size() == 4); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		first = PointListUtilities.pickClosestPoint(intersections, p2);
		assertTrue(
			"This is not the closest intersection to " + p2, first.x == 0 && first.y == 10); //$NON-NLS-1$
		second = PointListUtilities.pickFarestPoint(intersections, p2);
		assertTrue(
			"This is not the farest intersection to " + p2, second.x == 10 && second.y == 0); //$NON-NLS-1$
	}

	public void testAllLineIntersectionsWithEllipse() {
		Rectangle oval = new Rectangle(Rectangle.SINGLETON);
		oval.setLocation(-2, -1);
		oval.setSize(4, 2);

		// 2 points intersection
		Point p1 = new Point(0, 0);
		Point p2 = new Point(3, 0);
		LineSeg line = new LineSeg(p1,p2);
		PointList intersections = line.getLineIntersectionsWithEllipse(oval);
		assertTrue(
			"Must have 2 intersections with line passing through points " + p1 + " and " + p2, intersections.size() == 2); //$NON-NLS-1$//$NON-NLS-2$
		Point first = PointListUtilities.pickClosestPoint(intersections, p2);
		assertTrue(
			"This is not the closes intersection to " + p2, first.x == 2 && first.y == 0); //$NON-NLS-1$
		Point second = PointListUtilities.pickFarestPoint(intersections, p2);
		assertTrue(
			"This is not the farest intersection to " + p2, second.x == -2 && second.y == 0); //$NON-NLS-1$

		// 1 point intersection
		p1 = new Point(2, -2);
		p2 = new Point(2, 2);
		line = new LineSeg(p1,p2);
		intersections = line.getLineIntersectionsWithEllipse(oval);
		assertTrue(
			"Line passing through " + p1 + " and " + p2 + "must have exactly 1 intersections with the figure", intersections.size() == 2); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		first = PointListUtilities.pickClosestPoint(intersections, p2);
		second = PointListUtilities.pickFarestPoint(intersections, p2);
		assertTrue(second.x == first.x && second.y == first.y); 
		assertTrue(
			"Incorrect value for intersection point", first.x == 2 && first.y == 0); //$NON-NLS-1$

		// no intersections
		p1 = new Point(3, 0);
		p2 = new Point(0, 3);
		line = new LineSeg(p1,p2);
		intersections = line.getLineIntersectionsWithEllipse(oval);
		assertTrue(
			"Line passing through " + p1 + " and " + p2 + "must have no intersections with the figure", intersections.size() == 0); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}

}