Subversion Repositories hibernate-spatial

Compare Revisions

Ignore whitespace Rev 305 → Rev 306

/branches/Jts_mgeom_wkb/hibernate-spatial/src/test/java/org/hibernatespatial/jts/test/TestMeasuredGeometryConstruction.java
New file
0,0 → 1,77
package org.hibernatespatial.jts.test;
 
import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.CoordinateSequence;
import com.vividsolutions.jts.geom.GeometryFactory;
import com.vividsolutions.jts.geom.LineString;
import org.hibernatespatial.jts.geom.MeasuredCoordinate;
import org.hibernatespatial.jts.geom.MeasuredCoordinateSequence;
import org.hibernatespatial.jts.geom.MeasuredCoordinateSequenceFactory;
 
import org.junit.Test;
 
import static junit.framework.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
 
/**
* Tests the construction of <code>MeasuredGeometry</code>s.
* @author Karel Maesen, Geovise BVBA
* creation-date: Nov 29, 2010
*/
public class TestMeasuredGeometryConstruction {
 
MeasuredCoordinateSequenceFactory coordinateFactory = new MeasuredCoordinateSequenceFactory();
GeometryFactory geometryFactory = new GeometryFactory(coordinateFactory);
 
@Test
public void test_linestring_created_with_measuredcoordinatesequence() {
 
MeasuredCoordinateSequence coordinates = coordinateFactory.create(3, 2);
coordinates.setMeasuredCoordinate(0, MeasuredCoordinate.to2DM(1,2,3));
coordinates.setMeasuredCoordinate(1, MeasuredCoordinate.to2DM(3,4,5));
coordinates.setMeasuredCoordinate(2, MeasuredCoordinate.to2DM(6,7,8));
LineString lineString = geometryFactory.createLineString(coordinates);
 
assertTrue(lineString.getCoordinateN(0).equals2D(new Coordinate(1,2)));
assertTrue(lineString.getCoordinateN(1).equals2D(new Coordinate(3,4)));
assertTrue(lineString.getCoordinateN(2).equals2D(new Coordinate(6,7)));
 
 
assertEquals(3, lineString.getCoordinateSequence().getOrdinate(0, CoordinateSequence.M), Math.ulp(10d));
assertEquals(5, lineString.getCoordinateSequence().getOrdinate(1, CoordinateSequence.M), Math.ulp(10d));
assertEquals(8, lineString.getCoordinateSequence().getOrdinate(2, CoordinateSequence.M), Math.ulp(10d));
 
assertTrue(Double.isNaN(lineString.getCoordinateSequence().getOrdinate(0, CoordinateSequence.Z)));
assertTrue(Double.isNaN(lineString.getCoordinateSequence().getOrdinate(1, CoordinateSequence.Z)));
assertTrue(Double.isNaN(lineString.getCoordinateSequence().getOrdinate(2, CoordinateSequence.Z)));
}
 
@Test
public void test_linestring_created_with_coordinatesequence() {
 
Coordinate[] coordinates = new Coordinate[]{
new Coordinate(1,2),
new Coordinate(3,4),
new Coordinate(6,7)};
 
LineString lineString = geometryFactory.createLineString(coordinates);
 
assertTrue(lineString.getCoordinateN(0).equals2D(new Coordinate(1,2)));
assertTrue(lineString.getCoordinateN(1).equals2D(new Coordinate(3,4)));
assertTrue(lineString.getCoordinateN(2).equals2D(new Coordinate(6,7)));
 
 
assertTrue(Double.isNaN(lineString.getCoordinateSequence().getOrdinate(0, CoordinateSequence.M)));
assertTrue(Double.isNaN(lineString.getCoordinateSequence().getOrdinate(1, CoordinateSequence.M)));
assertTrue(Double.isNaN(lineString.getCoordinateSequence().getOrdinate(2, CoordinateSequence.M)));
assertTrue(Double.isNaN(lineString.getCoordinateSequence().getOrdinate(0, CoordinateSequence.Z)));
assertTrue(Double.isNaN(lineString.getCoordinateSequence().getOrdinate(1, CoordinateSequence.Z)));
assertTrue(Double.isNaN(lineString.getCoordinateSequence().getOrdinate(2, CoordinateSequence.Z)));
 
 
}
 
 
 
}
/branches/Jts_mgeom_wkb/hibernate-spatial/src/test/java/org/hibernatespatial/jts/geom/TestMeasuredCoordinateSequence.java
New file
0,0 → 1,307
package org.hibernatespatial.jts.geom;
 
import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.CoordinateSequence;
import com.vividsolutions.jts.geom.impl.CoordinateArraySequence;
import org.hibernatespatial.jts.geom.MeasuredCoordinate;
import org.hibernatespatial.jts.geom.MeasuredCoordinateArraySequence;
import org.hibernatespatial.jts.geom.MeasuredCoordinateSequence;
import org.hibernatespatial.jts.geom.MeasuredCoordinateSequenceFactory;
import org.junit.Test;
 
import static org.junit.Assert.*;
 
/**
* @author Karel Maesen, Geovise BVBA
* creation-date: Nov 22, 2010
*/
public class TestMeasuredCoordinateSequence {
 
 
private MeasuredCoordinateSequence seq;
 
@Test
public void test_constructor_size() {
 
MeasuredCoordinateSequenceFactory mcsf = new MeasuredCoordinateSequenceFactory();
seq = mcsf.create(2, 4);
Coordinate c0 = new Coordinate(1, 2, 3);
seq.setMeasuredCoordinate(0, new MeasuredCoordinate(c0, 4));
Coordinate c1 = new Coordinate(5, 6, 7);
seq.setMeasuredCoordinate(1, new MeasuredCoordinate(c1, 8));
assertEquals(c0, seq.getCoordinate(0));
assertEquals(4d, seq.getM(0), Math.ulp(4d));
assertEquals(c1, seq.getCoordinate(1));
assertEquals(8d, seq.getM(1), Math.ulp(8d));
 
try {
seq.setMeasuredCoordinate(2, new MeasuredCoordinate(c1, 8));
fail();
} catch (ArrayIndexOutOfBoundsException e) {
}
 
 
}
 
@Test
public void test_constructor_coordinate_array() {
Coordinate[] coordinates = new Coordinate[]{
new Coordinate(1, 1),
new Coordinate(2, 3),
new Coordinate(4, 5)
};
 
seq = new MeasuredCoordinateArraySequence(coordinates);
assertEquals(coordinates.length, seq.size());
assertEquals(4, seq.getDimension());
assertEquals(4, seq.getOrdinate(2, CoordinateSequence.X), Math.ulp(4f));
assertEquals(5, seq.getOrdinate(2, CoordinateSequence.Y), Math.ulp(5f));
assertEquals(Double.NaN, seq.getOrdinate(2, CoordinateSequence.M), 0.1f);
//test null parameter
seq = new MeasuredCoordinateArraySequence((Coordinate[])null);
assertEquals(0, seq.size());
 
}
 
@Test
public void test_constructor_coordinateseq() {
CoordinateSequence s = new CoordinateArraySequence(10);
seq = new MeasuredCoordinateArraySequence(s);
assertEquals(10, seq.size());
 
MeasuredCoordinateSequence ms = new MeasuredCoordinateArraySequence(3);
ms.setMeasuredCoordinate(0, MeasuredCoordinate.to2DM(1, 2, 1));
ms.setMeasuredCoordinate(1, MeasuredCoordinate.to2DM(3, 4, 2));
ms.setMeasuredCoordinate(2, MeasuredCoordinate.to2DM(5, 6, 3));
seq = new MeasuredCoordinateArraySequence((CoordinateSequence) ms);
 
assertEquals(1, seq.getOrdinate(0, CoordinateSequence.X), Math.ulp(10));
assertEquals(2, seq.getOrdinate(0, CoordinateSequence.Y), Math.ulp(10));
assertTrue(Double.isNaN(seq.getOrdinate(0, CoordinateSequence.Z)));
assertEquals(1, seq.getOrdinate(0, CoordinateSequence.M), Math.ulp(10));
 
assertEquals(3, seq.getOrdinate(1, CoordinateSequence.X), Math.ulp(10));
assertEquals(4, seq.getOrdinate(1, CoordinateSequence.Y), Math.ulp(10));
assertTrue(Double.isNaN(seq.getOrdinate(1, CoordinateSequence.Z)));
assertEquals(2, seq.getOrdinate(1, CoordinateSequence.M), Math.ulp(10));
 
assertEquals(5, seq.getOrdinate(2, CoordinateSequence.X), Math.ulp(10));
assertEquals(6, seq.getOrdinate(2, CoordinateSequence.Y), Math.ulp(10));
assertTrue(Double.isNaN(seq.getOrdinate(2, CoordinateSequence.Z)));
assertEquals(3, seq.getOrdinate(2, CoordinateSequence.M), Math.ulp(10));
 
//test null paramater
seq = new MeasuredCoordinateArraySequence((CoordinateSequence)null);
assertEquals(0, seq.size());
 
}
 
@Test
public void test_constructor_coordinateseq_doubles() {
CoordinateSequence s = new CoordinateArraySequence(10);
double[] measures = new double[10];
seq = new MeasuredCoordinateArraySequence(s, measures);
assertEquals(10, seq.size());
 
try {
double[] m2 = new double[8];
seq = new MeasuredCoordinateArraySequence(s, m2);
fail();
} catch (IllegalArgumentException e) {
}
 
seq = new MeasuredCoordinateArraySequence((CoordinateSequence) null, null);
assertEquals(0, seq.size());
 
//test null paramater
seq = new MeasuredCoordinateArraySequence((CoordinateSequence)null, null);
assertEquals(0, seq.size());
 
}
 
@Test
public void test_constructor_coordinates_doubles() {
Coordinate[] s = new Coordinate[10];
double[] measures = new double[10];
seq = new MeasuredCoordinateArraySequence(s, measures);
assertEquals(10, seq.size());
 
try {
double[] m2 = new double[8];
seq = new MeasuredCoordinateArraySequence(s, m2);
fail();
} catch (IllegalArgumentException e) {
}
 
seq = new MeasuredCoordinateArraySequence((Coordinate[]) null, null);
assertEquals(0, seq.size());
 
}
 
@Test
public void test_constructor_measurecoordinateseq() {
MeasuredCoordinateSequence ms = new MeasuredCoordinateArraySequence(3);
ms.setMeasuredCoordinate(0, MeasuredCoordinate.to2DM(1, 2, 1));
ms.setMeasuredCoordinate(1, MeasuredCoordinate.to2DM(3, 4, 2));
ms.setMeasuredCoordinate(2, MeasuredCoordinate.to2DM(5, 6, 3));
 
seq = new MeasuredCoordinateArraySequence(ms);
assertEquals(1, seq.getOrdinate(0, CoordinateSequence.X), Math.ulp(10));
assertEquals(2, seq.getOrdinate(0, CoordinateSequence.Y), Math.ulp(10));
assertTrue(Double.isNaN(seq.getOrdinate(0, CoordinateSequence.Z)));
assertEquals(1, seq.getOrdinate(0, CoordinateSequence.M), Math.ulp(10));
 
assertEquals(3, seq.getOrdinate(1, CoordinateSequence.X), Math.ulp(10));
assertEquals(4, seq.getOrdinate(1, CoordinateSequence.Y), Math.ulp(10));
assertTrue(Double.isNaN(seq.getOrdinate(1, CoordinateSequence.Z)));
assertEquals(2, seq.getOrdinate(1, CoordinateSequence.M), Math.ulp(10));
 
assertEquals(5, seq.getOrdinate(2, CoordinateSequence.X), Math.ulp(10));
assertEquals(6, seq.getOrdinate(2, CoordinateSequence.Y), Math.ulp(10));
assertTrue(Double.isNaN(seq.getOrdinate(2, CoordinateSequence.Z)));
assertEquals(3, seq.getOrdinate(2, CoordinateSequence.M), Math.ulp(10));
 
seq = new MeasuredCoordinateArraySequence((MeasuredCoordinateSequence) null);
assertEquals(0, seq.size());
}
 
@Test
public void test_constructor_measurecoordinates() {
MeasuredCoordinate[] ms = new MeasuredCoordinate[3];
ms[0] = MeasuredCoordinate.to2DM(1, 2, 1);
ms[1] = MeasuredCoordinate.to2DM(3, 4, 2);
ms[2] = MeasuredCoordinate.to2DM(5, 6, 3);
 
seq = new MeasuredCoordinateArraySequence(ms);
assertEquals(1, seq.getOrdinate(0, CoordinateSequence.X), Math.ulp(10));
assertEquals(2, seq.getOrdinate(0, CoordinateSequence.Y), Math.ulp(10));
assertTrue(Double.isNaN(seq.getOrdinate(0, CoordinateSequence.Z)));
assertEquals(1, seq.getOrdinate(0, CoordinateSequence.M), Math.ulp(10));
 
assertEquals(3, seq.getOrdinate(1, CoordinateSequence.X), Math.ulp(10));
assertEquals(4, seq.getOrdinate(1, CoordinateSequence.Y), Math.ulp(10));
assertTrue(Double.isNaN(seq.getOrdinate(1, CoordinateSequence.Z)));
assertEquals(2, seq.getOrdinate(1, CoordinateSequence.M), Math.ulp(10));
 
assertEquals(5, seq.getOrdinate(2, CoordinateSequence.X), Math.ulp(10));
assertEquals(6, seq.getOrdinate(2, CoordinateSequence.Y), Math.ulp(10));
assertTrue(Double.isNaN(seq.getOrdinate(2, CoordinateSequence.Z)));
assertEquals(3, seq.getOrdinate(2, CoordinateSequence.M), Math.ulp(10));
 
seq = new MeasuredCoordinateArraySequence((MeasuredCoordinate[]) null);
assertEquals(0, seq.size());
 
}
 
@Test
public void test_can_set_m_ordinates() {
seq = new MeasuredCoordinateArraySequence(2);
seq.setOrdinate(0, CoordinateSequence.X, 0);
seq.setOrdinate(0, CoordinateSequence.Y, 1);
seq.setOrdinate(0, CoordinateSequence.Z, 2);
seq.setOrdinate(0, CoordinateSequence.M, 3);
for (int i = 0; i < seq.getDimension(); i++) {
assertEquals(i, seq.getOrdinate(0, i), Math.ulp(10));
}
}
 
@Test
public void test_if_on_create_m_ordinates_are_NaN() {
seq = new MeasuredCoordinateArraySequence(2);
seq.setOrdinate(0, CoordinateSequence.X, 0);
seq.setOrdinate(0, CoordinateSequence.Y, 1);
seq.setOrdinate(0, CoordinateSequence.Z, 2);
assertTrue(Double.isNaN(seq.getOrdinate(0, CoordinateSequence.M)));
assertTrue(Double.isNaN(seq.getM(0)));
}
 
 
@Test
public void test_get_m() {
seq = new MeasuredCoordinateArraySequence(2);
seq.setOrdinate(0, CoordinateSequence.X, 0);
seq.setOrdinate(0, CoordinateSequence.Y, 1);
seq.setOrdinate(0, CoordinateSequence.Z, 2);
seq.setOrdinate(0, CoordinateSequence.M, 3);
assertEquals(0, seq.getX(0), Math.ulp(10d));
assertEquals(1, seq.getY(0), Math.ulp(10d));
assertEquals(2, seq.getZ(0), Math.ulp(10d));
assertEquals(3, seq.getM(0), Math.ulp(10d));
 
}
 
@Test
public void test_setCoordinateAndM() {
seq = new MeasuredCoordinateArraySequence(2);
seq.setMeasuredCoordinate(0, MeasuredCoordinate.to3DM(0, 1, 2, 3));
for (int i = 0; i < seq.getDimension(); i++) {
assertEquals(i, seq.getOrdinate(0, i), Math.ulp(10d));
}
 
}
 
@Test
public void test_test_copy_measured_coordinate_index_coordinate(){
 
seq = new MeasuredCoordinateArraySequence(4);
seq.setMeasuredCoordinate(2, MeasuredCoordinate.to3DM(0, 1, 2, 3));
 
MeasuredCoordinate mCoordinate = new MeasuredCoordinate();
 
seq.getMeasuredCoordinate(0, mCoordinate);
assertEquals(0, mCoordinate.getX(), Math.ulp(10d));
assertEquals(0, mCoordinate.getY(), Math.ulp(10d));
assertEquals(Double.NaN, mCoordinate.getZ(), Math.ulp(10d));
assertEquals(Double.NaN, mCoordinate.getM(), Math.ulp(10d));
 
seq.getMeasuredCoordinate(2, mCoordinate);
assertEquals(0, mCoordinate.getX(), Math.ulp(10d));
assertEquals(1, mCoordinate.getY(), Math.ulp(10d));
assertEquals(2, mCoordinate.getZ(), Math.ulp(10d));
assertEquals(3, mCoordinate.getM(), Math.ulp(10d));
 
 
seq.setMeasuredCoordinate(1, MeasuredCoordinate.to2D(0, 1));
seq.getMeasuredCoordinate(1, mCoordinate);
assertEquals(0, mCoordinate.getX(), Math.ulp(10d));
assertEquals(1, mCoordinate.getY(), Math.ulp(10d));
assertEquals(Double.NaN, mCoordinate.getZ(), Math.ulp(10d));
assertEquals(Double.NaN, mCoordinate.getM(), Math.ulp(10d));
 
seq.setMeasuredCoordinate(3, MeasuredCoordinate.to2DM(0, 1, 2));
seq.getMeasuredCoordinate(3, mCoordinate);
assertEquals(0, mCoordinate.getX(), Math.ulp(10d));
assertEquals(1, mCoordinate.getY(), Math.ulp(10d));
assertEquals(Double.NaN, mCoordinate.getZ(), Math.ulp(10d));
assertEquals(2, mCoordinate.getM(), Math.ulp(10d));
 
 
}
 
@Test
public void test_clone() {
seq = new MeasuredCoordinateArraySequence(2);
MeasuredCoordinate mc0 = MeasuredCoordinate.to3DM(0, 1, 2, 3);
MeasuredCoordinate mc1 = MeasuredCoordinate.to3DM(4, 5, 6, 7);
seq.setMeasuredCoordinate(0, mc0);
seq.setMeasuredCoordinate(1, mc1);
 
MeasuredCoordinateArraySequence cloned = (MeasuredCoordinateArraySequence) seq.clone();
//check that clone has same values as original
 
assertTrue(mc0.equals3DWithMeasure(cloned.getMeasuredCoordinate(0)));
assertTrue(mc1.equals3DWithMeasure(cloned.getMeasuredCoordinate(1)));
 
//check independence
cloned.setOrdinate(0, CoordinateSequence.M, 10);
cloned.setOrdinate(1, CoordinateSequence.M, 11);
//check that clone has same values as original
assertEquals(3, seq.getOrdinate(0, CoordinateSequence.M), Math.ulp(10d));
assertEquals(7, seq.getOrdinate(1, CoordinateSequence.M), Math.ulp(10d));
 
assertFalse(mc0.equals3DWithMeasure(cloned.getMeasuredCoordinate(0)));
assertFalse(mc1.equals3DWithMeasure(cloned.getMeasuredCoordinate(1)));
}
 
}
/branches/Jts_mgeom_wkb/hibernate-spatial/src/test/java/org/hibernatespatial/jts/linearref/TestMeasuredLineString.java
New file
0,0 → 1,428
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());
 
}
 
 
}
/branches/Jts_mgeom_wkb/hibernate-spatial/src/test/java/org/hibernatespatial/wkb/TestWKBGeometryType.java
New file
0,0 → 1,25
package org.hibernatespatial.wkb;
 
import org.junit.Test;
 
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
 
/**
* @author Karel Maesen, Geovise BVBA
* creation-date: Nov 11, 2010
*/
public class TestWKBGeometryType {
 
@Test
public void test_code_point(){
WKBGeometryType wgt = WKBGeometryType.valueOf(1);
assertEquals(WKBGeometryType.POINT, wgt);
 
}
 
 
 
 
}
/branches/Jts_mgeom_wkb/hibernate-spatial/src/test/java/org/hibernatespatial/wkb/TestWKB.java
New file
0,0 → 1,81
package org.hibernatespatial.wkb;
 
import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.io.ParseException;
import org.hibernatespatial.test.EWKTReader;
import org.hibernatespatial.test.GeometryEquality;
import org.junit.Test;
 
import java.util.*;
 
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
 
/**
* @author Karel Maesen, Geovise BVBA
* creation-date: Nov 11, 2010
*/
public class TestWKB {
 
public static final Map<String, String> testcases = new HashMap<String, String>();
public static final EWKTReader wktReader = new EWKTReader();
public static final GeometryEquality equalityTest = new GeometryEquality();
 
static {
testcases.put("POINT(10 3)", "010100000000000000000024400000000000000840");
testcases.put("POINT(1 2 3)", "0101000080000000000000F03F00000000000000400000000000000840");
testcases.put("POINT(1 2 3 4)", "01010000C0000000000000F03F000000000000004000000000000008400000000000001040");
testcases.put("POINTM(1 2 4)", "0101000040000000000000F03F00000000000000400000000000001040");
testcases.put("SRID=4326;POINT(1 2 3 4)", "01010000E0E6100000000000000000F03F000000000000004000000000000008400000000000001040");
// testcases.put(" LINESTRING(1 2,3 4,5 6)", "010200000003000000000000000000F03F00000000000000400000000000000840000000000000104000000000000014400000000000001840");
 
}
 
 
@Test
public void test_decode() throws ParseException, UnsupportedConversionException {
for (String wkt : testcases.keySet()) {
Geometry geom;
if (wkt.startsWith("SRID=")) {
String[] tokens=wkt.split(";");
int srid = getSrid(tokens[0]);
geom = wktReader.read(tokens[1]);
geom.setSRID(srid);
}else{
geom = wktReader.read(wkt);
}
Bytes bytes = Bytes.from(testcases.get(wkt));
Geometry received = WKB.fromWKB(bytes);
assertTrue("Failure decoding: " + wkt, equalityTest.test(geom, received));
}
}
 
private int getSrid(String sridDeclaration) {
String[] tokens = sridDeclaration.split("=");
return Integer.parseInt(tokens[1]);
}
 
@Test
public void test_encode() throws ParseException, UnsupportedConversionException {
for (String wkt : testcases.keySet()) {
Geometry geom = wktReader.read(wkt);
Bytes bytes = WKB.toWKB(geom, WKBByteOrder.NDR);
assertEquals("Failure encoding: " + wkt, testcases.get(wkt), bytes.toString());
}
}
 
 
//TODO -- use all test cases -- find a cleaner way to test for ndr/xdr encoding/decoding
@Test
public void test_point_with_ndr_byte_order() throws ParseException, UnsupportedConversionException {
String wkt = "POINT(10 3)";
Geometry geom = wktReader.read(wkt);
Bytes bytes = WKB.toWKB(geom, WKBByteOrder.NDR);
assertNotNull(bytes);
System.out.println("bytes = " + bytes.toString());
assertTrue(equalityTest.test(geom, WKB.fromWKB(bytes)));
 
 
}
}
/branches/Jts_mgeom_wkb/hibernate-spatial/src/test/java/org/hibernatespatial/wkb/TestBytes.java
New file
0,0 → 1,242
package org.hibernatespatial.wkb;
 
import org.junit.Test;
 
import static junit.framework.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
 
/**
* @author Karel Maesen, Geovise BVBA
* creation-date: Oct 29, 2010
*/
public class TestBytes {
 
@Test
public void testBytesFromString() {
 
String byteTxt = "0120E6FF";
Bytes bStream = Bytes.from(byteTxt);
 
assertEquals(4, bStream.limit());
 
assertEquals(1, bStream.get());
assertEquals(32, bStream.get());
assertEquals((byte) 230, bStream.get());
assertEquals((byte) 255, bStream.get());
 
}
 
@Test
public void test_bytes_from_odd_length_string() {
String byteTxt = "0120E6FFE";
Bytes bStream = Bytes.from(byteTxt);
assertEquals(4, bStream.limit());
 
}
 
@Test
public void test_throws_NumberFormatException_if_string_not_hexadecimal() {
try {
Bytes.from("02FFKK");
fail();
} catch (NumberFormatException e) {
//OK
}
}
 
@Test
public void test_return_empty_Bytes_on_empty_string() {
Bytes bytes = Bytes.from("");
assertTrue(bytes.isEmpty());
assertEquals(0, bytes.limit());
}
 
@Test
public void test_throw_IllegalArgumentException_on_null_string() {
try {
Bytes bytes = Bytes.from((String) null);
fail();
} catch (IllegalArgumentException e) {
//OK
}
}
 
 
@Test
public void test_toString(){
String hxStr = "037FB4C7";
Bytes bytes = Bytes.from(hxStr);
assertEquals(hxStr, bytes.toString());
 
}
 
@Test
public void test_big_endian_int() {
String hxStr = "037FB4C7";
int expectedValue = 58700999;
 
Bytes bytes = Bytes.from(hxStr);
bytes.setWKBByteOrder(WKBByteOrder.XDR);
assertEquals(expectedValue, bytes.getInt());
}
 
@Test
public void test_string_or_bytes_gives_same_result() {
String hxStr = "037FB4C7";
byte[] byteArray = new byte[]{0x03, 0x7F, (byte) 0xB4, (byte) 0xC7};
int expectedValue = 58700999;
 
Bytes bytes = Bytes.from(hxStr);
bytes.setWKBByteOrder(WKBByteOrder.XDR);
assertEquals(expectedValue, bytes.getInt());
 
Bytes bytesFromArray = Bytes.from(byteArray);
bytesFromArray.setWKBByteOrder(WKBByteOrder.XDR);
assertEquals(expectedValue, bytesFromArray.getInt());
}
 
@Test
public void test_little_endian_int() {
String hxStr = "C7B47F03";
int expectedValue = 58700999;
 
Bytes bytes = Bytes.from(hxStr);
bytes.setWKBByteOrder(WKBByteOrder.NDR);
assertEquals(expectedValue, bytes.getInt());
}
 
@Test
public void test_insufficient_bytes_for_retrieving_long_throws_exception() {
String hxStr = "C7B47F03";
Bytes bytes = Bytes.from(hxStr);
try {
Long lng = bytes.getLong();
} catch (RuntimeException e) {
//OK
}
 
}
 
@Test
public void test_get_unsigned_as_long() {
String hxStr = "FFFFFFFF";
Bytes bytes = Bytes.from(hxStr);
long expected = 4294967295L;
assertEquals(expected, bytes.getUInt());
 
bytes = Bytes.from("80000000");
assertEquals(2147483648L, bytes.getUInt());
 
bytes = Bytes.from("00000001");
assertEquals(1L, bytes.getUInt());
 
bytes = Bytes.from("7FFFFFFF");
assertEquals(2147483647L, bytes.getUInt());
 
}
 
@Test
public void test_retrieve_byteorder() {
String hxStr = "FFFFFFFF";
Bytes bytes = Bytes.from(hxStr);
bytes.setWKBByteOrder(WKBByteOrder.XDR);
assertEquals(WKBByteOrder.XDR, bytes.getWKBByteOrder());
bytes.setWKBByteOrder(WKBByteOrder.NDR);
assertEquals(WKBByteOrder.NDR, bytes.getWKBByteOrder());
}
 
@Test
public void test_create_bytes_having_specified_size() {
Bytes bytes = Bytes.allocate(100);
assertEquals(100, bytes.capacity());
}
 
@Test
public void test_put_xdr_double() {
double expected = 1234.56789;
Bytes bytes = Bytes.allocate(8);
bytes.setWKBByteOrder(WKBByteOrder.XDR);
bytes.putDouble(expected);
bytes.rewind();
double d = bytes.getDouble();
assertEquals(expected, d);
}
 
@Test
public void test_put_ndr_double() {
double expected = 1234.56789;
Bytes bytes = Bytes.allocate(8);
bytes.setWKBByteOrder(WKBByteOrder.NDR);
bytes.putDouble(expected);
bytes.rewind();
double d = bytes.getDouble();
assertEquals(expected, d);
}
 
@Test
public void test_put_byte() {
byte expected = (byte) 0xFF;
Bytes bytes = Bytes.allocate(1);
bytes.put(expected);
bytes.rewind();
assertEquals(expected, bytes.get());
}
 
@Test
public void test_put_int() {
int expected = 0xFF;
Bytes bytes = Bytes.allocate(4);
bytes.putInt(expected);
bytes.rewind();
assertEquals(expected, bytes.getInt());
}
 
@Test
public void test_put_long() {
long expected = Long.MAX_VALUE;
Bytes bytes = Bytes.allocate(8);
bytes.putLong(expected);
bytes.rewind();
assertEquals(expected, bytes.getLong());
}
 
 
@Test
public void test_put_float() {
float expected = 1234.567f;
Bytes bytes = Bytes.allocate(4);
bytes.putFloat(expected);
bytes.rewind();
assertEquals(expected, bytes.getFloat());
}
 
@Test
public void test_put_uint() {
long expected = 4294967295L;
Bytes bytes = Bytes.allocate(4);
bytes.putUInt(expected);
bytes.rewind();
assertEquals(expected, bytes.getUInt());
}
 
@Test
public void test_put_too_large_value_in_uint_throws_exception() {
long value = Bytes.UINT_MAX_VALUE;
Bytes bytes = Bytes.allocate(4);
bytes.putUInt(value);
bytes.rewind();
assertEquals(value, bytes.getUInt());
value++;
Bytes bytes2 = Bytes.allocate(4);
try {
bytes2.putUInt(value);
fail();
} catch (RuntimeException e) {
//OK
}
}
 
 
}