@Test
public void testNullOperations() throws Exception {
Value nullv = ValueFactory.createNullValue();
Value numv = ValueFactory.createValue(4d);
Value strv = ValueFactory.createValue("s");
Value falsev = numv.less(numv);
Value truev = numv.equals(numv);
assertTrue(nullv.multiply(numv).isNull());
assertTrue(numv.multiply(nullv).isNull());
assertTrue(nullv.sum(numv).isNull());
assertTrue(numv.sum(nullv).isNull());
assertTrue(strv.matches(nullv).isNull());
assertTrue(nullv.matches(strv).isNull());
assertTrue(falsev.or(nullv).isNull());
assertTrue(nullv.or(falsev).isNull());
assertTrue(truev.and(nullv).isNull());
assertTrue(nullv.and(truev).isNull());
assertTrue(numv.greaterEqual(nullv).isNull());
assertTrue(numv.equals(nullv).isNull());
assertTrue(numv.notEquals(nullv).isNull());
assertTrue(numv.less(nullv).isNull());
assertTrue(numv.lessEqual(nullv).isNull());
assertTrue(nullv.greaterEqual(numv).isNull());
assertTrue(nullv.equals(numv).isNull());
assertTrue(nullv.notEquals(numv).isNull());
assertTrue(nullv.less(numv).isNull());
assertTrue(nullv.lessEqual(numv).isNull());
}
private GeoRaster checkRasterMetadataIO(GeoRaster grSource) {
Value v = ValueFactory.createValue(grSource);
Value v2 = ValueFactory.createValue(v.getType(), v.getBytes());
GeoRaster gr = v2.getAsRaster();
assertEquals(gr.getMetadata(), grSource.getMetadata());
return gr;
}
@Test
public void testValueCollectionConversion() throws Exception {
Value value =
ValueFactory.createValue(
new Value[] {ValueFactory.createValue(2d), ValueFactory.createValue("hello")});
Set<Integer> set = new HashSet<Integer>();
set.add(13);
checkConversions(value, set);
}
@Test
public void testDecimalDigits() throws Exception {
assertEquals(((NumericValue) ValueFactory.createValue(2.3d)).getDecimalDigitsCount(), 1);
assertEquals(((NumericValue) ValueFactory.createValue(2d)).getDecimalDigitsCount(), 0);
assertEquals(((NumericValue) ValueFactory.createValue(23)).getDecimalDigitsCount(), 0);
assertEquals(((NumericValue) ValueFactory.createValue(2.030f)).getDecimalDigitsCount(), 2);
assertEquals(
((NumericValue) ValueFactory.createValue(2.00000000002d)).getDecimalDigitsCount(), 11);
}
/**
* DOCUMENT ME!
*
* @throws IncompatibleTypesException DOCUMENT ME!
*/
@Test
public void testStringValueEquals() throws IncompatibleTypesException {
Value v1 = ValueFactory.createValue("hola");
Value v2 = ValueFactory.createValue("hola");
Value v3 = ValueFactory.createValue("holA");
assertTrue((v1.equals(v2)).getAsBoolean());
assertFalse((v1.equals(v3)).getAsBoolean());
assertFalse((v2.equals(v3)).getAsBoolean());
}
/** We must be able to transform specialized collections to GeometryCollectionValues */
@Test
public void testGeometryCollectionConversions() throws Exception {
Value val =
ValueFactory.createValue(
gf.createMultiPoint(
new Coordinate[] {new Coordinate(0, 0, 0), new Coordinate(1, 2, 3)}));
assertTrue(val instanceof DefaultMultiPointValue);
Value val2 = val.toType(Type.GEOMETRYCOLLECTION);
assertTrue(val2 instanceof DefaultGeometryCollectionValue);
// Let's be sure it's not a GeometryCollection just thanks to the inheritance
assertFalse(val2 instanceof DefaultMultiPointValue);
val =
ValueFactory.createValue(
gf.createMultiLineString(
new LineString[] {
gf.createLineString(
new Coordinate[] {new Coordinate(0, 0, 0), new Coordinate(4, 2, 3)}),
gf.createLineString(
new Coordinate[] {new Coordinate(5, 6, 9), new Coordinate(5, 7, 1)})
}));
assertTrue(val instanceof DefaultMultiLineStringValue);
val2 = val.toType(Type.GEOMETRYCOLLECTION);
assertTrue(val2 instanceof DefaultGeometryCollectionValue);
// Let's be sure it's not a GeometryCollection just thanks to the inheritance
assertFalse(val2 instanceof DefaultMultiPointValue);
val =
ValueFactory.createValue(
gf.createMultiPolygon(
new Polygon[] {
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(0, 3, 0),
new Coordinate(9, 0, 0),
new Coordinate(8, 7, 0),
new Coordinate(0, 3, 0)
}),
null),
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(10, 3, 0),
new Coordinate(9, 0, 0),
new Coordinate(8, 7, 0),
new Coordinate(10, 3, 0)
}),
null)
}));
assertTrue(val instanceof DefaultMultiPolygonValue);
val2 = val.toType(Type.GEOMETRYCOLLECTION);
assertTrue(val2 instanceof DefaultGeometryCollectionValue);
// Let's be sure it's not a GeometryCollection just thanks to the inheritance
assertFalse(val2 instanceof DefaultMultiPointValue);
}
@Test
public void testBooleanComparisons() throws Exception {
Value v1 = ValueFactory.createValue(true);
Value v2 = ValueFactory.createValue(false);
assertEquals(v1.compareTo(v1), 0);
assertEquals(v2.compareTo(v2), 0);
assertEquals(v1.compareTo(v2), 1);
assertEquals(v2.compareTo(v1), -1);
}
@Test
public void testValuesTypes() throws Exception {
assertEquals(ValueFactory.createValue(false).getType(), Type.BOOLEAN);
assertEquals(ValueFactory.createValue(new byte[] {2, 3}).getType(), Type.BINARY);
assertEquals(ValueFactory.createValue(new Date()).getType(), Type.DATE);
assertEquals(ValueFactory.createValue(3.0d).getType(), Type.DOUBLE);
assertEquals(ValueFactory.createValue(3.5f).getType(), Type.FLOAT);
assertEquals(ValueFactory.createValue(4).getType(), Type.INT);
assertEquals(ValueFactory.createValue(4L).getType(), Type.LONG);
assertEquals(ValueFactory.createValue("").getType(), Type.STRING);
assertEquals(ValueFactory.createValue(new Time(1)).getType(), Type.TIME);
assertEquals(ValueFactory.createValue(new Timestamp(1)).getType(), Type.TIMESTAMP);
}
/**
* Test created to check that we effectively retrieve a good representation of empty
* multipolygons. indeed, a NullPointerException used to happen...
*
* @throws Exception
*/
@Test
public void testGeometryCollectionStringRepresentation() throws Exception {
GeometryCollection mp = gf.createMultiPolygon(new Polygon[] {});
Value val = ValueFactory.createValue(mp);
String str = val.toString();
assertEquals(str, "MULTIPOLYGON EMPTY");
Polygon poly = gf.createPolygon(gf.createLinearRing(new Coordinate[] {}), new LinearRing[] {});
assertTrue(poly.isEmpty());
mp =
gf.createMultiPolygon(
new Polygon[] {
poly,
});
val = ValueFactory.createValue(mp);
str = val.toString();
assertNotNull(str);
Polygon polyBis =
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(0, 0, 0),
new Coordinate(1, 1, 0),
new Coordinate(3, 4, 0),
new Coordinate(0, 0, 0),
}),
new LinearRing[] {});
mp = gf.createMultiPolygon(new Polygon[] {poly, polyBis});
val = ValueFactory.createValue(mp);
str = val.toString();
assertNotNull(str);
GeometryCollection coll =
gf.createGeometryCollection(
new Geometry[] {
gf.createPolygon(gf.createLinearRing(new Coordinate[] {}), new LinearRing[] {}),
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(0, 0, 0),
new Coordinate(1, 1, 0),
new Coordinate(3, 4, 0),
new Coordinate(0, 0, 0),
}),
new LinearRing[] {})
});
mp = gf.createGeometryCollection(new Geometry[] {poly, coll, polyBis});
val = ValueFactory.createValue(mp);
str = val.toString();
assertNotNull(str);
}
@Test
public void testTimestampValueConversion() throws Exception {
Value value = ValueFactory.createValue(new Timestamp(System.currentTimeMillis()));
Set<Integer> set = new HashSet<Integer>();
set.add(12);
checkConversions(value, set);
}
@Test
public void testStringValueConversion() throws Exception {
Value value = ValueFactory.createValue("gdms");
Set<Integer> set = new HashSet<Integer>();
set.add(10);
checkConversions(value, set);
}
@Test
public void testGeometryValueConversion() throws Exception {
Value value = ValueFactory.createValue(Geometries.getMultiPoint3D());
Set<Integer> set = new HashSet<Integer>();
set.add(6);
checkConversions(value, set);
}
@Test
public void testDateValueConversion() throws Exception {
Value value = ValueFactory.createValue(new Date());
Set<Integer> set = new HashSet<Integer>();
set.add(3);
checkConversions(value, set);
}
@Test
public void testBooleanValueConversion() throws Exception {
Value value = ValueFactory.createValue(false);
Set<Integer> set = new HashSet<Integer>();
set.add(1);
checkConversions(value, set);
}
@Test
public void testBinaryValueConversion() throws Exception {
Value binary = ValueFactory.createValue(new byte[] {3, 5, 7});
Set<Integer> set = new HashSet<Integer>();
set.add(0);
checkConversions(binary, set);
}
/**
* Time a multi-threaded access to a cache.
*
* @return the timing stopwatch
*/
private <V> StopWatch timeMultiThreaded(
String id, final Map<Integer, V> map, ValueFactory<V> factory) throws InterruptedException {
StopWatch stopWatch = new StopWatch(id);
for (int i = 0; i < 500; i++) {
map.put(i, factory.newValue(i));
}
Thread[] threads = new Thread[30];
stopWatch.start("Running threads");
for (int threadIndex = 0; threadIndex < threads.length; threadIndex++) {
threads[threadIndex] =
new Thread("Cache access thread " + threadIndex) {
@Override
public void run() {
for (int j = 0; j < 1000; j++) {
for (int i = 0; i < 1000; i++) {
map.get(i);
}
}
}
};
}
for (Thread thread : threads) {
thread.start();
}
for (Thread thread : threads) {
if (thread.isAlive()) {
thread.join(2000);
}
}
stopWatch.stop();
return stopWatch;
}
@Test
public void testNullValueConversion() throws Exception {
Value value = ValueFactory.createNullValue();
Set<Integer> set = new HashSet<Integer>();
for (int i = 0; i < 14; i++) {
set.add(i);
}
checkConversions(value, set);
}
@Test
public void testShortValueConversion() throws Exception {
Value value = ValueFactory.createValue(Short.MAX_VALUE);
Set<Integer> set = new HashSet<Integer>();
set.add(2);
set.add(4);
set.add(5);
set.add(7);
set.add(8);
set.add(9);
checkConversions(value, set);
}
@Test
public void testNumericValueComparisons() throws Exception {
Value v1 = ValueFactory.createValue(1);
Value v2 = ValueFactory.createValue(18);
Value v3 = ValueFactory.createValue(-5d);
Value v4 = ValueFactory.createValue(100d);
Value v5 = ValueFactory.createValue(18f);
// same value
assertEquals(v1.compareTo(v1), 0);
// opposite comparisons
assertEquals(v1.compareTo(v2), -1);
assertEquals(v2.compareTo(v1), 1);
// different types
assertEquals(v1.compareTo(v3), 1);
assertEquals(v2.compareTo(v4), -1);
assertEquals(v2.compareTo(v5), 0);
}
@Test
public void testArrayValue() throws Exception {
Value[] v = new Value[7];
for (int i = 0; i < v.length; i++) {
v[i] = ValueFactory.createValue(i);
}
ValueCollection av = ValueFactory.createValue(v);
for (int i = 0; i < v.length; i++) {
v[i] = ValueFactory.createValue(i);
}
ValueCollection av2 = ValueFactory.createValue(v);
assertTrue((av.equals(av2)).getAsBoolean());
assertEquals(av.hashCode(), av2.hashCode());
for (int i = 0; i < 7; i++) {
assertTrue((av.get(i).equals(ValueFactory.createValue(i))).getAsBoolean());
}
}
@Test
public void testTimeValuesComparisons() throws Exception {
DateFormat dateInstance = new SimpleDateFormat("yyyy/MM/dd");
Value v1 = ValueFactory.createValue(dateInstance.parse("2002/11/21"));
Value v2 = ValueFactory.createValue(dateInstance.parse("2010/01/11"));
assertEquals(v1.compareTo(v1), 0);
assertEquals(v1.compareTo(v2), -1);
assertEquals(v2.compareTo(v1), 1);
v1 = ValueFactory.createValue(Time.valueOf("18:01:59"));
v2 = ValueFactory.createValue(Time.valueOf("23:00:05"));
assertEquals(v1.compareTo(v1), 0);
assertEquals(v1.compareTo(v2), -1);
assertEquals(v2.compareTo(v1), 1);
v1 = ValueFactory.createValue(Timestamp.valueOf("2002-11-21 18:01:59"));
v2 = ValueFactory.createValue(Timestamp.valueOf("2010-01-11 23:00:05"));
assertEquals(v1.compareTo(v1), 0);
assertEquals(v1.compareTo(v2), -1);
assertEquals(v2.compareTo(v1), 1);
}
@Test
public void testGeometryConversions() throws Exception {
// Let's test with a PointValue
Value pt = ValueFactory.createValue(gf.createPoint(new Coordinate(0, 0, 0)));
assertTrue(pt instanceof DefaultPointValue);
Value mpt = pt.toType(Type.MULTIPOINT);
assertTrue(mpt instanceof DefaultMultiPointValue);
Value gpt = pt.toType(Type.GEOMETRY);
assertTrue(gpt instanceof DefaultPointValue);
Value gcpt = pt.toType(Type.GEOMETRYCOLLECTION);
assertTrue(gcpt instanceof DefaultGeometryCollectionValue);
assertFalse(gcpt instanceof DefaultMultiPointValue);
// We shall not be able to cast to a Line or a Polygon.
try {
gcpt = pt.toType(Type.POLYGON);
fail();
} catch (IncompatibleTypesException i) {
}
try {
gcpt = pt.toType(Type.LINESTRING);
fail();
} catch (IncompatibleTypesException i) {
}
// LineString time!!!
pt =
ValueFactory.createValue(
gf.createLineString(
new Coordinate[] {new Coordinate(0, 0, 0), new Coordinate(0, 1, 0)}));
assertTrue(pt instanceof DefaultLineStringValue);
mpt = pt.toType(Type.MULTILINESTRING);
assertTrue(mpt instanceof DefaultMultiLineStringValue);
gpt = pt.toType(Type.GEOMETRY);
assertTrue(gpt instanceof DefaultLineStringValue);
gcpt = pt.toType(Type.GEOMETRYCOLLECTION);
assertTrue(gcpt instanceof DefaultGeometryCollectionValue);
assertFalse(gcpt instanceof DefaultMultiPointValue);
// We shall not be able to cast to a Line or a Polygon.
try {
gcpt = pt.toType(Type.POLYGON);
fail();
} catch (IncompatibleTypesException i) {
}
try {
gcpt = pt.toType(Type.POINT);
fail();
} catch (IncompatibleTypesException i) {
}
// Let's test with a PolygonValue
pt =
ValueFactory.createValue(
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(0, 0, 0),
new Coordinate(0, 1, 0),
new Coordinate(1, 1, 0),
new Coordinate(0, 0, 0)
}),
null));
assertTrue(pt instanceof DefaultPolygonValue);
mpt = pt.toType(Type.MULTIPOLYGON);
assertTrue(mpt instanceof DefaultMultiPolygonValue);
gpt = pt.toType(Type.GEOMETRY);
assertTrue(gpt instanceof DefaultPolygonValue);
gcpt = pt.toType(Type.GEOMETRYCOLLECTION);
assertTrue(gcpt instanceof DefaultGeometryCollectionValue);
assertFalse(gcpt instanceof DefaultMultiPolygonValue);
// We shall not be able to cast to a Line or a Polygon.
try {
gcpt = pt.toType(Type.POINT);
fail();
} catch (IncompatibleTypesException i) {
}
try {
gcpt = pt.toType(Type.LINESTRING);
fail();
} catch (IncompatibleTypesException i) {
}
}
/**
* DOCUMENT ME!
*
* @throws Exception DOCUMENT ME!
*/
@Test
public void testCreateByType() throws Exception {
assertTrue(
(ValueFactory.createValueByType("1", Type.LONG).equals(ValueFactory.createValue(1L)))
.getAsBoolean());
assertTrue(
(ValueFactory.createValueByType("true", Type.BOOLEAN)
.equals(ValueFactory.createValue(true)))
.getAsBoolean());
assertTrue(
(ValueFactory.createValueByType("false", Type.BOOLEAN)
.equals(ValueFactory.createValue(false)))
.getAsBoolean());
assertTrue(
(ValueFactory.createValueByType("carajo", Type.STRING)
.equals(ValueFactory.createValue("carajo")))
.getAsBoolean());
Calendar c = Calendar.getInstance();
// month is 0-based
c.set(1980, 8, 5, 0, 0, 0);
c.set(Calendar.MILLISECOND, 0);
assertTrue(
(ValueFactory.createValueByType(d.toString(), Type.DATE)
.equals(ValueFactory.createValue(d)))
.getAsBoolean());
assertTrue(
(ValueFactory.createValueByType(
NumberFormat.getNumberInstance(Locale.ROOT).format(1.1), Type.DOUBLE)
.equals(ValueFactory.createValue(1.1d)))
.getAsBoolean());
assertTrue(
(ValueFactory.createValueByType("1", Type.INT).equals(ValueFactory.createValue(1)))
.getAsBoolean());
assertTrue(
(ValueFactory.createValueByType(
NumberFormat.getNumberInstance(Locale.ROOT).format(1.1), Type.FLOAT)
.equals(ValueFactory.createValue(1.1f)))
.getAsBoolean());
assertTrue(
(ValueFactory.createValueByType("1", Type.SHORT).equals(ValueFactory.createValue(1)))
.getAsBoolean());
assertTrue(
(ValueFactory.createValueByType("1", Type.BYTE).equals(ValueFactory.createValue(1)))
.getAsBoolean());
byte[] array = new byte[] {(byte) 255, (byte) 160, (byte) 7};
assertTrue(
(ValueFactory.createValueByType("FFA007", Type.BINARY)
.equals(ValueFactory.createValue(array)))
.getAsBoolean());
c.set(1970, 0, 1, 22, 45, 00);
c.set(Calendar.MILLISECOND, 0);
Time t = new Time(c.getTime().getTime());
assertTrue(
(ValueFactory.createValueByType(
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(t), Type.TIME)
.equals(ValueFactory.createValue(t)))
.getAsBoolean());
c.set(1970, 0, 1, 22, 45, 20);
c.set(Calendar.MILLISECOND, 2345);
Timestamp ts = new Timestamp(c.getTime().getTime());
assertTrue(
(ValueFactory.createValueByType(ts.toString(), Type.TIMESTAMP)
.equals(ValueFactory.createValue(ts)))
.getAsBoolean());
}
/** Tests the NullValues operations */
@Test
public void testNullValueOperations() throws Exception {
Value n = ValueFactory.createNullValue();
ValueCollection b = ValueFactory.createValue(new Value[0]);
assertTrue((b.equals(n)).isNull());
assertTrue(b.notEquals(n).isNull());
Value v = ValueFactory.createValue(true);
v.and(n);
v.or(n);
// SQL UNKNOWN
assertNull((v.equals(n)).getAsBoolean());
assertNull((v.notEquals(n)).getAsBoolean());
Value i = ValueFactory.createValue(1);
i.equals(n);
i.notEquals(n);
assertTrue((i.less(n)).isNull());
assertTrue((i.lessEqual(n)).isNull());
assertTrue((i.greater(n)).isNull());
assertTrue((i.greaterEqual(n)).isNull());
Value s = ValueFactory.createValue("test");
assertTrue((s.equals(n)).isNull());
assertTrue((s.notEquals(n)).isNull());
assertTrue((s.less(n)).isNull());
assertTrue((s.lessEqual(n)).isNull());
assertTrue((s.greater(n)).isNull());
assertTrue((s.greaterEqual(n)).isNull());
s.matches(n);
Value d = ValueFactory.createValue(new Date());
assertTrue((d.equals(n)).isNull());
assertTrue((d.notEquals(n)).isNull());
assertTrue((d.less(n)).isNull());
assertTrue((d.lessEqual(n)).isNull());
assertTrue((d.greater(n)).isNull());
assertTrue((d.greaterEqual(n)).isNull());
Value t = ValueFactory.createValue(new Time(12));
assertTrue((t.equals(n)).isNull());
assertTrue((t.notEquals(n)).isNull());
assertTrue((t.less(n)).isNull());
assertTrue((t.lessEqual(n)).isNull());
assertTrue((t.greater(n)).isNull());
assertTrue((t.greaterEqual(n)).isNull());
Value ts = ValueFactory.createValue(new Timestamp(12));
assertTrue((ts.equals(n)).isNull());
assertTrue((ts.notEquals(n)).isNull());
assertTrue((ts.less(n)).isNull());
assertTrue((ts.lessEqual(n)).isNull());
assertTrue((ts.greater(n)).isNull());
assertTrue((ts.greaterEqual(n)).isNull());
assertTrue((n.equals(n)).isNull());
assertTrue((n.notEquals(n)).isNull());
assertTrue((n.less(n)).isNull());
assertTrue((n.lessEqual(n)).isNull());
assertTrue((n.greater(n)).isNull());
assertTrue((n.greaterEqual(n)).isNull());
n.matches(n);
}
@Test
public void testValueCollectionComparisons() {
ValueCollection v1 =
ValueFactory.createValue(
new Value[] {ValueFactory.createValue(18), ValueFactory.createValue("abc")});
ValueCollection v2 =
ValueFactory.createValue(
new Value[] {ValueFactory.createValue(18), ValueFactory.createValue("acc")});
ValueCollection v3 =
ValueFactory.createValue(
new Value[] {ValueFactory.createValue(19), ValueFactory.createValue("abc")});
ValueCollection v4 =
ValueFactory.createValue(
new Value[] {ValueFactory.createValue(-12), ValueFactory.createValue("abc")});
assertEquals(0, v1.compareTo(v1));
assertEquals(1, v2.compareTo(v1));
assertEquals(-1, v1.compareTo(v3));
assertEquals(1, v1.compareTo(v4));
assertTrue(v1.less(v2).getAsBoolean());
assertTrue(v2.lessEqual(v2).getAsBoolean());
assertTrue(v3.greater(v2).getAsBoolean());
assertTrue(v4.greaterEqual(v4).getAsBoolean());
assertTrue(v3.greaterEqual(v4).getAsBoolean());
}
@Test
public void testToStringFromStringCoherente() throws Exception {
Value v = ValueFactory.createValue(1300.5566d);
assertTrue(
(v.equals(ValueFactory.createValueByType(v.toString(), Type.DOUBLE))).getAsBoolean());
v = ValueFactory.createValue(13.5f);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.FLOAT))).getAsBoolean());
v = ValueFactory.createValue(1300L);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.LONG))).getAsBoolean());
v = ValueFactory.createValue(false);
assertTrue(
(v.equals(ValueFactory.createValueByType(v.toString(), Type.BOOLEAN))).getAsBoolean());
v = ValueFactory.createValue("hola");
assertTrue(
(v.equals(ValueFactory.createValueByType(v.toString(), Type.STRING))).getAsBoolean());
Calendar c = Calendar.getInstance();
// month is 0-based
c.set(1980, 8, 5, 0, 0, 0);
c.set(Calendar.MILLISECOND, 0);
v = ValueFactory.createValue(d);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.DATE))).getAsBoolean());
v = ValueFactory.createValue(15);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.INT))).getAsBoolean());
v = ValueFactory.createValue((short) 13);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.SHORT))).getAsBoolean());
v = ValueFactory.createValue((byte) 5);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.BYTE))).getAsBoolean());
v = ValueFactory.createValue(new byte[] {4, 5, 7, 8, 3, 8});
assertTrue(
(v.equals(ValueFactory.createValueByType(v.toString(), Type.BINARY))).getAsBoolean());
c.set(1970, 0, 1, 22, 45, 20);
c.set(Calendar.MILLISECOND, 0);
Time t = new Time(c.getTime().getTime());
v = ValueFactory.createValue(t);
assertTrue((v.equals(ValueFactory.createValueByType(v.toString(), Type.TIME))).getAsBoolean());
v = ValueFactory.createValue(new Timestamp(2465));
assertTrue(
(v.equals(ValueFactory.createValueByType(v.toString(), Type.TIMESTAMP))).getAsBoolean());
}
@Test
public void test3DGeoms() throws Exception {
Coordinate[] coords2D =
new Coordinate[] {
new Coordinate(10, 10, 10),
new Coordinate(40, 10, 10),
new Coordinate(40, 40, 10),
new Coordinate(10, 40, 10),
new Coordinate(10, 10, 10),
};
Coordinate[] coords3D =
new Coordinate[] {
new Coordinate(10, 10),
new Coordinate(40, 10),
new Coordinate(40, 40),
new Coordinate(10, 40),
new Coordinate(10, 10),
};
Value p1 = ValueFactory.createValue(gf.createPoint(new Coordinate(10, 10, 10)));
Value p2 = ValueFactory.createValue(gf.createPoint(new Coordinate(10, 10)));
checkDifferent(p1, p2);
LineString l1 = gf.createLineString(coords2D);
p1 = ValueFactory.createValue(l1);
LineString l2 = gf.createLineString(coords3D);
p2 = ValueFactory.createValue(l2);
checkDifferent(p1, p2);
p1 = ValueFactory.createValue(gf.createMultiPoint(coords2D));
p2 = ValueFactory.createValue(gf.createMultiPoint(coords3D));
checkDifferent(p1, p2);
Polygon pol1 = gf.createPolygon(gf.createLinearRing(coords2D), null);
p1 = ValueFactory.createValue(pol1);
Polygon pol2 = gf.createPolygon(gf.createLinearRing(coords3D), null);
p2 = ValueFactory.createValue(pol2);
checkDifferent(p1, p2);
p1 = ValueFactory.createValue(gf.createMultiLineString(new LineString[] {l1}));
p2 = ValueFactory.createValue(gf.createMultiLineString(new LineString[] {l2}));
checkDifferent(p1, p2);
p1 = ValueFactory.createValue(gf.createMultiPolygon(new Polygon[] {pol1}));
p2 = ValueFactory.createValue(gf.createMultiPolygon(new Polygon[] {pol2}));
checkDifferent(p1, p2);
}
@Test(expected = ParseException.class)
public void testEmptyStringIsNotValidGeometry() throws Exception {
ValueFactory.createValueByType("", Type.GEOMETRY);
}
private void checkIO(Value v) throws IncompatibleTypesException {
Value v2 = ValueFactory.createValue(v.getType(), v.getBytes());
assertTrue((v2.equals(v)).getAsBoolean());
}
//
// public void testValueConversion() throws Exception {
// Value intValue = ValueFactory.createValue(3);
// Value doubleValue = ValueFactory.createValue(3.5d);
// Value stringValue = ValueFactory.createValue("12");
// Value boolStringValue = ValueFactory.createValue("false");
// Value booleanValue = ValueFactory.createValue(true);
// long longValue = System.currentTimeMillis();
// Value timeValue = ValueFactory.createValue(new Time(longValue));
// Value dateValue = ValueFactory.createValue(new Date(longValue));
//
// checkToString(intType, stringType, intValue);
// checkToString(intType, doubleType, intValue);
// checkToString(doubleType, stringType, doubleValue);
// checkToString(stringType, intType, stringValue);
// checkToString(stringType, booleanType, boolStringValue);
// checkToString(booleanType, stringType, booleanValue);
//
// BooleanValue bv = dateValue.toType(
// timeType.getTypeCode()).equals(timeValue);
// assertTrue(bv.getAsBoolean());
// }
//
// private void checkToString(Type firstType, Type secondType, Value value)
// throws IncompatibleTypesException {
// Value newValue = value.toType(secondType.getTypeCode()).toType(
// firstType.getTypeCode());
// assertEquals(( newValue,value));
// }
@Test
public void testValuesIO() throws Exception {
Value v;
v = ValueFactory.createValue(false);
checkIO(v);
v = ValueFactory.createValue(new byte[] {2, 3, 6});
checkIO(v);
v = ValueFactory.createValue(new Date());
checkIO(v);
v = ValueFactory.createValue((short) 32700);
checkIO(v);
v = ValueFactory.createValue(421359827);
checkIO(v);
v = ValueFactory.createValue(1080131636);
checkIO(v);
v = ValueFactory.createValue(3.0975525d);
checkIO(v);
v = ValueFactory.createValue(3.52345f);
checkIO(v);
v = ValueFactory.createValue(8223372036854780000L);
checkIO(v);
v = ValueFactory.createValue("asdg");
checkIO(v);
v = ValueFactory.createValue(new Time(1));
checkIO(v);
v = ValueFactory.createValue(new Timestamp(1));
checkIO(v);
v = ValueFactory.createValue(new GeometryFactory().createPoint(new Coordinate(10, 10, 10)));
checkIO(v);
v = ValueFactory.createValue(new GeometryFactory().createPoint(new Coordinate(10, 10)));
checkIO(v);
}