Subversion Repositories hibernate-spatial

package org.hibernatespatial.jts.linearref;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.Point;

import org.hibernatespatial.jts.geom.MeasuredCoordinate;

import org.hibernatespatial.jts.geom.MeasuredCoordinateSequence;

import org.hibernatespatial.jts.geom.MeasuredCoordinateSequenceFactory;

import org.junit.Before;

import org.junit.Test;

import static junit.framework.Assert.assertNull;

import static junit.framework.Assert.fail;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertTrue;

/**

 * @author Karel Maesen, Geovise BVBA

 *         creation-date: Nov 29, 2010

 */

public class TestMeasuredLineString {

    MeasuredCoordinateSequenceFactory coordinateFactory = new MeasuredCoordinateSequenceFactory();

    GeometryFactory geometryFactory = new GeometryFactory(coordinateFactory);

    MeasuredLineString mli;

    LineString[] testLineStrings;

    @Before

    public void setUp() {

        MeasuredCoordinateSequence seq0 = coordinateFactory.create(4, 4);

        seq0.setMeasuredCoordinate(0, MeasuredCoordinate.to2DM(1, 2, 0));

        seq0.setMeasuredCoordinate(1, MeasuredCoordinate.to2DM(2, 3, 1));

        seq0.setMeasuredCoordinate(2, MeasuredCoordinate.to2DM(3, 4, 2));

        seq0.setMeasuredCoordinate(3, MeasuredCoordinate.to2DM(4, 5, 3));

        //monotonic increasing

        MeasuredCoordinateSequence seq1 = coordinateFactory.create(4, 4);

        seq1.setMeasuredCoordinate(0, MeasuredCoordinate.to2DM(0, 0, 0));

        seq1.setMeasuredCoordinate(1, MeasuredCoordinate.to2DM(1, 0, 1));

        seq1.setMeasuredCoordinate(2, MeasuredCoordinate.to2DM(2, 0, 2));

        seq1.setMeasuredCoordinate(3, MeasuredCoordinate.to2DM(3, 0, 3));

        //monotonic decreasing

        MeasuredCoordinateSequence seq2 = coordinateFactory.create(4, 4);

        seq2.setMeasuredCoordinate(0, MeasuredCoordinate.to2DM(3, 0, 3));

        seq2.setMeasuredCoordinate(1, MeasuredCoordinate.to2DM(2, 0, 2));

        seq2.setMeasuredCoordinate(2, MeasuredCoordinate.to2DM(1, 0, 1));

        seq2.setMeasuredCoordinate(3, MeasuredCoordinate.to2DM(0, 0, 0));

        //non-monotonic

        MeasuredCoordinateSequence seq3 = coordinateFactory.create(4, 4);

        seq3.setMeasuredCoordinate(0, MeasuredCoordinate.to2DM(1, 0, 0));

        seq3.setMeasuredCoordinate(1, MeasuredCoordinate.to2DM(2, 0, 5));

        seq3.setMeasuredCoordinate(2, MeasuredCoordinate.to2DM(3, 0, 2));

        seq3.setMeasuredCoordinate(3, MeasuredCoordinate.to2DM(8, 0, 7));

        //non-measured

        MeasuredCoordinateSequence seq4 = coordinateFactory.create(4, 4);

        seq4.setMeasuredCoordinate(0, MeasuredCoordinate.to2D(1, 0));

        seq4.setMeasuredCoordinate(1, MeasuredCoordinate.to2D(2, 0));

        seq4.setMeasuredCoordinate(2, MeasuredCoordinate.to2D(3, 0));

        seq4.setMeasuredCoordinate(3, MeasuredCoordinate.to2D(8, 0));

        //non-strict monotonic increasing

        MeasuredCoordinateSequence seq5 = coordinateFactory.create(4, 4);

        seq5.setMeasuredCoordinate(0, MeasuredCoordinate.to2DM(0, 0, 0));

        seq5.setMeasuredCoordinate(1, MeasuredCoordinate.to2DM(1, 0, 1));

        seq5.setMeasuredCoordinate(2, MeasuredCoordinate.to2DM(2, 0, 1));

        seq5.setMeasuredCoordinate(3, MeasuredCoordinate.to2DM(3, 0, 2));

        //monotonic decreasing

        MeasuredCoordinateSequence seq6 = coordinateFactory.create(4, 4);

        seq6.setMeasuredCoordinate(0, MeasuredCoordinate.to2DM(3, 0, 2));

        seq6.setMeasuredCoordinate(1, MeasuredCoordinate.to2DM(2, 0, 1));

        seq6.setMeasuredCoordinate(2, MeasuredCoordinate.to2DM(1, 0, 1));

        seq6.setMeasuredCoordinate(3, MeasuredCoordinate.to2DM(0, 0, 0));

        testLineStrings = new LineString[]{

                geometryFactory.createLineString(seq0),

                geometryFactory.createLineString(seq1),

                geometryFactory.createLineString(seq2),

                geometryFactory.createLineString(seq3),

                geometryFactory.createLineString(seq4),

                geometryFactory.createLineString(seq5),

                geometryFactory.createLineString(seq6)

        };

    }

    @Test

    public void test_constructor_on_null() {

        try {

            mli = new MeasuredLineString(null);

            fail();

        } catch (IllegalArgumentException e) {

            //OK

        }

    }

    @Test

    public void test_get_measure_at_coordinate() {

        mli = new MeasuredLineString(testLineStrings[1]);

        double received = mli.getMeasureAtCoordinate(new Coordinate(1.5d, 0d), 0.01d);

        assertEquals(1.5d, received, Math.ulp(5d));

        received = mli.getMeasureAtCoordinate(new Coordinate(0.0d, 0d), 0.01d);

        assertEquals(0d, received, Math.ulp(5d));

        received = mli.getMeasureAtCoordinate(new Coordinate(2.0d, 0d), 0.01d);

        assertEquals(2d, received, Math.ulp(5d));

        received = mli.getMeasureAtCoordinate(new Coordinate(3.009d, 0d), 0.01d);

        assertEquals(3d, received, Math.ulp(5d));

        received = mli.getMeasureAtCoordinate(new Coordinate(5.0d, 0d), 0.01d);

        assertTrue(Double.isNaN(received));

    }

    @Test

    public void test_get_coordinate_at_measure_monotone_increasing() {

        mli = new MeasuredLineString(testLineStrings[1]);

        assertNull(mli.getCoordinateAtMeasure(-1d));

        assertNull(mli.getCoordinateAtMeasure(3.2d));

        assertEquals(MeasuredCoordinate.to2DM(0, 0, 0), mli.getCoordinateAtMeasure(0));

        assertEquals(MeasuredCoordinate.to2DM(0.8, 0, 0.8), mli.getCoordinateAtMeasure(0.8));

        assertEquals(MeasuredCoordinate.to2DM(2.1, 0.0, 2.1), mli.getCoordinateAtMeasure(2.1));

        assertEquals(MeasuredCoordinate.to2DM(3.0, 0, 3.0), mli.getCoordinateAtMeasure(3));

    }

    @Test

    public void test_get_coordinate_at_measure_non_strict_monotone_increasing() {

        mli = new MeasuredLineString(testLineStrings[5]);

        assertNull(mli.getCoordinateAtMeasure(-1d));

        assertNull(mli.getCoordinateAtMeasure(3.2d));

        assertEquals(MeasuredCoordinate.to2DM(0, 0, 0), mli.getCoordinateAtMeasure(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0, 0, 1.0), mli.getCoordinateAtMeasure(1.0));

    }

    @Test

    public void test_get_coordinate_at_measure_monotone_decreasing() {

        mli = new MeasuredLineString(testLineStrings[2]);

        assertNull(mli.getCoordinateAtMeasure(-1d));

        assertNull(mli.getCoordinateAtMeasure(3.2d));

        assertEquals(MeasuredCoordinate.to2DM(0, 0, 0), mli.getCoordinateAtMeasure(0));

        assertEquals(MeasuredCoordinate.to2DM(0.8, 0, 0.8), mli.getCoordinateAtMeasure(0.8));

        assertEquals(MeasuredCoordinate.to2DM(2.1, 0.0, 2.1), mli.getCoordinateAtMeasure(2.1));

        assertEquals(MeasuredCoordinate.to2DM(3.0, 0, 3.0), mli.getCoordinateAtMeasure(3));

    }

    @Test

    public void test_get_coordinate_at_measure_non_monotone() {

        mli = new MeasuredLineString(testLineStrings[3]);

        assertNull(mli.getCoordinateAtMeasure(-1d));

        assertNull(mli.getCoordinateAtMeasure(9d));

        assertEquals(MeasuredCoordinate.to2DM(1, 0, 0), mli.getCoordinateAtMeasure(0));

        assertEquals(MeasuredCoordinate.to2DM(1.5, 0, 2.5), mli.getCoordinateAtMeasure(2.5));

        assertEquals(MeasuredCoordinate.to2DM(2.0, 0.0, 5.0d), mli.getCoordinateAtMeasure(5.0d));

        assertEquals(MeasuredCoordinate.to2DM(7.0, 0, 6.0), mli.getCoordinateAtMeasure(6));

    }

    @Test

    public void test_min_measure() {

        for (int i = 0; i < 4; i++) {

            mli = new MeasuredLineString(testLineStrings[i]);

            assertEquals(0.0d, mli.getMinMeasure(), Math.ulp(1.0d));

        }

        mli = new MeasuredLineString(testLineStrings[4]);

        assertTrue(Double.isNaN(mli.getMinMeasure()));

    }

    @Test

    public void test_max_measure() {

        for (int i = 0; i < 3; i++) {

            mli = new MeasuredLineString(testLineStrings[i]);

            assertEquals(3.0d, mli.getMaxMeasure(), Math.ulp(1.0d));

        }

        mli = new MeasuredLineString(testLineStrings[3]);

        assertEquals(7.0d, mli.getMaxMeasure(), Math.ulp(1.0d));

        mli = new MeasuredLineString(testLineStrings[4]);

        assertTrue(Double.isNaN(mli.getMaxMeasure()));

    }

    @Test

    public void test_get_coordinates_between_monotone_increasing() {

        mli = new MeasuredLineString(testLineStrings[1]);

        MeasuredCoordinateSequence[] sequences = mli.getCoordinatesBetween(1.5d, 2.5d);

        assertEquals(1, sequences.length);

        assertEquals(3, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(1.5d, 0.0d, 1.5d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(2.0d, 0.0d, 2.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(2.5d, 0.0d, 2.5d), sequences[0].getMeasuredCoordinate(2));

        sequences = mli.getCoordinatesBetween(0.25d, 0.75d);

        assertEquals(1, sequences.length);

        assertEquals(2, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(0.25d, 0.0d, 0.25d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(0.75d, 0.0d, 0.75d), sequences[0].getMeasuredCoordinate(1));

        sequences = mli.getCoordinatesBetween(0d, 1.5d);

        assertEquals(1, sequences.length);

        assertEquals(3, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(0.0d, 0.0d, 0.0d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(1.5d, 0.0d, 1.5d), sequences[0].getMeasuredCoordinate(2));

        sequences = mli.getCoordinatesBetween(1.5d, 0d);

        assertEquals(1, sequences.length);

        assertEquals(3, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(0.0d, 0.0d, 0.0d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(1.5d, 0.0d, 1.5d), sequences[0].getMeasuredCoordinate(2));

        sequences = mli.getCoordinatesBetween(-1d, 1.5d);

        assertEquals(1, sequences.length);

        assertEquals(3, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(0.0d, 0.0d, 0.0d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(1.5d, 0.0d, 1.5d), sequences[0].getMeasuredCoordinate(2));

        sequences = mli.getCoordinatesBetween(-1d, -0.5d);

        assertEquals(1, sequences.length);

        assertEquals(0, sequences[0].size());

        sequences = mli.getCoordinatesBetween(0.5d, 5d);

        assertEquals(1, sequences.length);

        assertEquals(4, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(0.5d, 0.0d, 0.5d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(2.0d, 0.0d, 2.0d), sequences[0].getMeasuredCoordinate(2));

        assertEquals(MeasuredCoordinate.to2DM(3.0d, 0.0d, 3.0d), sequences[0].getMeasuredCoordinate(3));

        sequences = mli.getCoordinatesBetween(2.5d, 2.75d);

        assertEquals(1, sequences.length);

        assertEquals(2, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(2.5d, 0.0d, 2.5d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(2.75d, 0.0d, 2.75d), sequences[0].getMeasuredCoordinate(1));

        sequences = mli.getCoordinatesBetween(0.0d, 0.0d);

        assertEquals(1, sequences.length);

        assertEquals(0, sequences[0].size());

        sequences = mli.getCoordinatesBetween(0.0d, 1.0d);

        assertEquals(1, sequences.length);

        assertEquals(2, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(0.0d, 0.0d, 0.0d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

    }

    @Test

    public void test_get_coordinates_between_monotone_decreasing() {

        mli = new MeasuredLineString(testLineStrings[2]);

        MeasuredCoordinateSequence[] sequences = mli.getCoordinatesBetween(1.5d, 2.5d);

        assertEquals(1, sequences.length);

        assertEquals(3, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(2.5d, 0.0d, 2.5d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(2.0d, 0.0d, 2.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(1.5d, 0.0d, 1.5d), sequences[0].getMeasuredCoordinate(2));

        sequences = mli.getCoordinatesBetween(0d, 1.5d);

        assertEquals(1, sequences.length);

        assertEquals(3, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(1.5d, 0.0d, 1.5d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(0.0d, 0.0d, 0.0d), sequences[0].getMeasuredCoordinate(2));

        sequences = mli.getCoordinatesBetween(1.5d, 0d);

        assertEquals(1, sequences.length);

        assertEquals(3, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(1.5d, 0.0d, 1.5d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(0.0d, 0.0d, 0.0d), sequences[0].getMeasuredCoordinate(2));

        sequences = mli.getCoordinatesBetween(-1d, 1.5d);

        assertEquals(1, sequences.length);

        assertEquals(3, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(1.5d, 0.0d, 1.5d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(0.0d, 0.0d, 0.0d), sequences[0].getMeasuredCoordinate(2));

        sequences = mli.getCoordinatesBetween(-1d, -0.5d);

        assertEquals(1, sequences.length);

        assertEquals(0, sequences[0].size());

        sequences = mli.getCoordinatesBetween(0.5d, 5d);

        assertEquals(1, sequences.length);

        assertEquals(4, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(3.0d, 0.0d, 3.0d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(2.0d, 0.0d, 2.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(2));

        assertEquals(MeasuredCoordinate.to2DM(0.5d, 0.0d, 0.5d), sequences[0].getMeasuredCoordinate(3));

        sequences = mli.getCoordinatesBetween(0.0d, 0.0d);

        assertEquals(1, sequences.length);

        assertEquals(0, sequences[0].size());

        sequences = mli.getCoordinatesBetween(0.0d, 1.0d);

        assertEquals(1, sequences.length);

        assertEquals(2, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(0.0d, 0.0d, 0.0d), sequences[0].getMeasuredCoordinate(1));

    }

    @Test

    public void test_get_coordinates_between_non_strict_monotone_increasing() {

        mli = new MeasuredLineString(testLineStrings[5]);

        MeasuredCoordinateSequence[] sequences = mli.getCoordinatesBetween(0.5d, 1.5d);

        assertEquals(1, sequences.length);

        assertEquals(4, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(0.5d, 0.0d, 0.5d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(2.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(2));

        assertEquals(MeasuredCoordinate.to2DM(2.5d, 0.0d, 1.5d), sequences[0].getMeasuredCoordinate(3));

        sequences = mli.getCoordinatesBetween(0.5d, 1.0d);

        assertEquals(1, sequences.length);

        assertEquals(3, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(0.5d, 0.0d, 0.5d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(2.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(2));

        sequences = mli.getCoordinatesBetween(1.5d, 0.5d);

        assertEquals(1, sequences.length);

        assertEquals(4, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(0.5d, 0.0d, 0.5d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(2.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(2));

        assertEquals(MeasuredCoordinate.to2DM(2.5d, 0.0d, 1.5d), sequences[0].getMeasuredCoordinate(3));

    }

    @Test

    public void test_get_coordinates_between_non_strict_monotone_decreasing() {

        mli = new MeasuredLineString(testLineStrings[6]);

        MeasuredCoordinateSequence[] sequences = mli.getCoordinatesBetween(0.5d, 1.5d);

        assertEquals(1, sequences.length);

        assertEquals(4, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(2.5d, 0.0d, 1.5d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(2.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(2));

        assertEquals(MeasuredCoordinate.to2DM(0.5d, 0.0d, 0.5d), sequences[0].getMeasuredCoordinate(3));

        sequences = mli.getCoordinatesBetween(0.5d, 1.0d);

        assertEquals(1, sequences.length);

        assertEquals(3, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(2.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(0.5d, 0.0d, 0.5d), sequences[0].getMeasuredCoordinate(2));

        sequences = mli.getCoordinatesBetween(1.5d, 0.5d);

        assertEquals(1, sequences.length);

        assertEquals(4, sequences[0].size());

        assertEquals(MeasuredCoordinate.to2DM(2.5d, 0.0d, 1.5d), sequences[0].getMeasuredCoordinate(0));

        assertEquals(MeasuredCoordinate.to2DM(2.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(1));

        assertEquals(MeasuredCoordinate.to2DM(1.0d, 0.0d, 1.0d), sequences[0].getMeasuredCoordinate(2));

        assertEquals(MeasuredCoordinate.to2DM(0.5d, 0.0d, 0.5d), sequences[0].getMeasuredCoordinate(3));

    }

    @Test

    public void test_get_coordinates_between_non_monotone() {

        mli = new MeasuredLineString(testLineStrings[3]);

        try {

            MeasuredCoordinateSequence[] sequences = mli.getCoordinatesBetween(1.5d, 2.5d);

            fail();

        } catch(IllegalStateException e){

            //OK

        }

    }

    @Test

    public void test_locate_along(){

        mli = new MeasuredLineString(testLineStrings[1]);

        Point received = (Point)mli.locateAlong(0.0d);

        MeasuredCoordinateSequence mseq = (MeasuredCoordinateSequence)received.getCoordinateSequence();

        assertEquals(MeasuredCoordinate.to2DM(0,0,0), mseq.getMeasuredCoordinate(0));

        received = (Point)mli.locateAlong(0.5d);

        mseq = (MeasuredCoordinateSequence)received.getCoordinateSequence();

        assertEquals(MeasuredCoordinate.to2DM(0.5,0,0.5), mseq.getMeasuredCoordinate(0));

        received = (Point)mli.locateAlong(2.5d);

        mseq = (MeasuredCoordinateSequence)received.getCoordinateSequence();

        assertEquals(MeasuredCoordinate.to2DM(2.5,0,2.5), mseq.getMeasuredCoordinate(0));

        received = (Point)mli.locateAlong(3.5d);

        assertTrue(received.isEmpty());

    }

}