From 715ac511547381f21e9e1c0e6d5c3597aecbf84c Mon Sep 17 00:00:00 2001 From: Ana Marjanica Date: Mon, 29 Dec 2014 17:08:38 +0100 Subject: [PATCH 1/4] Point converter & tests (to fix failing NaN) --- .../PGNullableConverterBuilder.scala | 2 + .../PGNullablePointConverterBuilder.scala | 22 +++- .../converters/PGNullablePointConverter.java | 36 +++++++ .../pgscala/converters/test/PointTest.scala | 100 ++++++++++++++++++ .../pgscala/converters/PGNullableConverter.j | 16 +++ .../org/pgscala/converters/Implicits.scala | 64 +++++------ 6 files changed, 206 insertions(+), 34 deletions(-) create mode 100644 converters-java/src/generated/java/org/pgscala/converters/PGNullablePointConverter.java create mode 100644 converters-java/src/test/scala/org/pgscala/converters/test/PointTest.scala diff --git a/builder/src/main/scala/org/pgscala/builder/converters/PGNullableConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/PGNullableConverterBuilder.scala index 22aaed4..7729e89 100644 --- a/builder/src/main/scala/org/pgscala/builder/converters/PGNullableConverterBuilder.scala +++ b/builder/src/main/scala/org/pgscala/builder/converters/PGNullableConverterBuilder.scala @@ -147,6 +147,8 @@ object PGNullableConverterBuilder extends PGConverterBuilderPaths { , PGNullableElemConverterBuilder , PGNullableMapConverterBuilder + + , PGNullablePointConverterBuilder ) def buildJavaNullableConverters() { diff --git a/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullablePointConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullablePointConverterBuilder.scala index 1dadf97..79a8d68 100644 --- a/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullablePointConverterBuilder.scala +++ b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullablePointConverterBuilder.scala @@ -3,11 +3,25 @@ package builder package converters object PGNullablePointConverterBuilder extends PGPredefNullableConverterBuilder { - val pgType = "bigint" + val pgType = "point" - val clazz = "java.lang.Long" + val clazz = "java.awt.geom.Point2D" - val to = "Long.toString(l)" + override val upperType = "Point" + override def javaType = clazz + + val to = """return "("+ p.getX()+","+p.getY()+")"""" - val from = "Long.valueOf(l)" + val from = """ + double x = Double.valueOf(p.substring(1, p.indexOf(","))); + double y = Double.valueOf(p.substring(p.indexOf(",")+1, p.length()-1)); + return new java.awt.geom.Point2D.Double(x, y)""" + + override def inject(body: String) = + super.inject(body) + .replace( + "return null == p ? null :", + """if (null == p) return null; + """) } + diff --git a/converters-java/src/generated/java/org/pgscala/converters/PGNullablePointConverter.java b/converters-java/src/generated/java/org/pgscala/converters/PGNullablePointConverter.java new file mode 100644 index 0000000..6f60f49 --- /dev/null +++ b/converters-java/src/generated/java/org/pgscala/converters/PGNullablePointConverter.java @@ -0,0 +1,36 @@ +package org.pgscala.converters; + +import org.joda.convert.*; + +/** Do not edit - generated in Builder / PGNullablePointConverterBuilder.scala */ + +public enum PGNullablePointConverter implements StringConverter { + INSTANCE; + + public static final String pgType = "point"; + + @ToString + public static String pointToString(final java.awt.geom.Point2D p) { + if (null == p) return null; + return "("+ p.getX()+","+p.getY()+")"; + } + + @FromString + public static java.awt.geom.Point2D stringToPoint(final String p) { + if (null == p) return null; + + double x = Double.valueOf(p.substring(1, p.indexOf(","))); + double y = Double.valueOf(p.substring(p.indexOf(",")+1, p.length()-1)); + return new java.awt.geom.Point2D.Double(x, y); + } + +// ----------------------------------------------------------------------------- + + public String convertToString(final java.awt.geom.Point2D p) { + return pointToString(p); + } + + public java.awt.geom.Point2D convertFromString(final Class clazz, final String p) { + return stringToPoint(p); + } +} diff --git a/converters-java/src/test/scala/org/pgscala/converters/test/PointTest.scala b/converters-java/src/test/scala/org/pgscala/converters/test/PointTest.scala new file mode 100644 index 0000000..ba918ad --- /dev/null +++ b/converters-java/src/test/scala/org/pgscala/converters/test/PointTest.scala @@ -0,0 +1,100 @@ +package org.pgscala.converters +package test + +import org.junit.runner.RunWith +import org.scalatest.junit.JUnitRunner +import org.scalatest.FeatureSpec +import org.scalatest.GivenWhenThen +import org.scalatest.Matchers + +@RunWith(classOf[JUnitRunner]) +class PointTest extends FeatureSpec with GivenWhenThen with Matchers { + feature("About to test an Point converter") { + info("I want to test if PGNullablePointConverter works correctly, both in 2 way conversion") + info("I am going to perform tests for the Point boundary cases") + + scenario("Double Point to String Nr. 1") { + Given("a starting Point(Double.Min, Double.MaxValue)") + val p = new java.awt.geom.Point2D.Double(Double.MaxValue, Double.MinValue); + val res = PGNullablePointConverter pointToString p + When(s"that value is converted to String $res") + val expectedResult = s"(${Double.MaxValue.toDouble},${Double.MinValue.toDouble})" + Then(s"It should return a String value $expectedResult") + res should equal(expectedResult) + } + + scenario("Double Point to String Nr. 2") { + Given("a starting Point(Double.NaN, Double.NaN)") + val p = new java.awt.geom.Point2D.Double(Double.NaN, Double.NaN); + When("that value is converted to String") + val res = PGNullablePointConverter pointToString p + val expectedResult = s"(${Double.NaN},${Double.NaN})" + Then(s"It should return a String value $expectedResult") + res should equal(expectedResult) + } + + scenario("Double Point to String Nr. 3") { + Given("a starting Point(0,0)") + val p = new java.awt.geom.Point2D.Double(0, 0); + val res = PGNullablePointConverter pointToString p + When(s"that value is converted to String $res") + val expectedResult = s"(${0d},${0d})" + Then(s"It should return a String value $expectedResult") + res should equal(expectedResult) + } + + scenario("Double Point to String Nr. 4") { + Given("a starting Point(Double.PositiveInfinity, Double.NegativeInfinity)") + val p = new java.awt.geom.Point2D.Double(Double.PositiveInfinity, Double.NegativeInfinity); + When("that value is converted to String") + val res = PGNullablePointConverter pointToString p + val expectedResult = s"(${Double.PositiveInfinity},${Double.NegativeInfinity})" + Then(s"It should return a String value $expectedResult") + res should equal(expectedResult) + } + +// scenario("Db test Nr. 1") { +// PGTestDb. +// } + + scenario("String to Point Nr. 1") { + Given("a starting String (Double.Min, Double.MaxValue)") + val given = s"(${Double.MaxValue.toDouble},${Double.MinValue.toDouble})" + val res = PGNullablePointConverter stringToPoint given + When(s"that value is converted to String $res") + val expectedResult = new java.awt.geom.Point2D.Double(Double.MaxValue, Double.MinValue); + Then(s"It should return a Point $expectedResult") + res should equal(expectedResult) + } + + scenario("String to Point Nr. 2") { + Given("a starting String (Double.NaN, Double.NaN)") + val given = s"(${Double.NaN},${Double.NaN})" + val res = PGNullablePointConverter stringToPoint(given) + When(s"that value is converted to String $res") + val expectedResult = new java.awt.geom.Point2D.Double(Double.NaN, Double.NaN); + Then(s"It should return a Point value $expectedResult") + res should equal(expectedResult) + } + + scenario("String to Point Nr. 3") { + Given("a starting Point(0,0)") + val given = s"(${0d},${0d})" + val res = PGNullablePointConverter stringToPoint given + When(s"that value is converted to String $res") + val expectedResult = new java.awt.geom.Point2D.Double(0, 0) + Then(s"It should return a String value $expectedResult") + res should equal(expectedResult) + } + + scenario("String to Point Nr. 4") { + Given("a starting Point(Double.PositiveInfinity, Double.NegativeInfinity)") + val given = s"(${Double.PositiveInfinity},${Double.NegativeInfinity})" + val res = PGNullablePointConverter stringToPoint(given) + When(s"that value is converted to String $res") + val expectedResult = new java.awt.geom.Point2D.Double(Double.PositiveInfinity, Double.NegativeInfinity); + Then(s"It should return a Point value $expectedResult") + res should equal(expectedResult) + } + } +} diff --git a/converters-scala/src/generated/jasmin/org/pgscala/converters/PGNullableConverter.j b/converters-scala/src/generated/jasmin/org/pgscala/converters/PGNullableConverter.j index e79dd5e..7fec67d 100644 --- a/converters-scala/src/generated/jasmin/org/pgscala/converters/PGNullableConverter.j +++ b/converters-scala/src/generated/jasmin/org/pgscala/converters/PGNullableConverter.j @@ -260,3 +260,19 @@ invokestatic org/pgscala/converters/PGNullableMapConverter.mapToString(Lscala.collection.immutable.Map;)Ljava/lang/String; areturn .end method + +.method public static fromPGString(Ljava/lang/String;)Ljava/awt/geom/Point2D; + .limit locals 1 + .limit stack 2 + aload_0 + invokestatic org/pgscala/converters/PGNullablePointConverter.stringToPoint(Ljava/lang/String;)Ljava/awt/geom/Point2D; + areturn +.end method + +.method public static toPGString(Ljava/awt/geom/Point2D;)Ljava/lang/String; + .limit locals 1 + .limit stack 2 + aload_0 + invokestatic org/pgscala/converters/PGNullablePointConverter.pointToString(Ljava/awt/geom/Point2D;)Ljava/lang/String; + areturn +.end method diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala b/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala index d56ba14..1b98e10 100644 --- a/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala +++ b/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala @@ -1,35 +1,39 @@ package org.pgscala.converters trait Implicits { - implicit val implicitPGStringConverter = PGStringConverter - implicit val implicitPGBooleanConverter = PGBooleanConverter - implicit val implicitPGShortConverter = PGShortConverter - implicit val implicitPGIntConverter = PGIntConverter - implicit val implicitPGLongConverter = PGLongConverter - implicit val implicitPGFloatConverter = PGFloatConverter - implicit val implicitPGDoubleConverter = PGDoubleConverter - implicit val implicitPGBigDecimalConverter = PGBigDecimalConverter - implicit val implicitPGBigIntConverter = PGBigIntConverter - implicit val implicitPGLocalDateConverter = PGLocalDateConverter - implicit val implicitPGDateTimeConverter = PGDateTimeConverter - implicit val implicitPGByteArrayConverter = PGByteArrayConverter - implicit val implicitPGUUIDConverter = PGUUIDConverter - implicit val implicitPGElemConverter = PGElemConverter - implicit val implicitPGMapConverter = PGMapConverter + implicit val implicitPGStringConverter = PGStringConverter + implicit val implicitPGBooleanConverter = PGBooleanConverter + implicit val implicitPGShortConverter = PGShortConverter + implicit val implicitPGIntConverter = PGIntConverter + implicit val implicitPGLongConverter = PGLongConverter + implicit val implicitPGFloatConverter = PGFloatConverter + implicit val implicitPGDoubleConverter = PGDoubleConverter + implicit val implicitPGBigDecimalConverter = PGBigDecimalConverter + implicit val implicitPGBigIntConverter = PGBigIntConverter + implicit val implicitPGLocalDateConverter = PGLocalDateConverter + implicit val implicitPGDateTimeConverter = PGDateTimeConverter + implicit val implicitPGByteArrayConverter = PGByteArrayConverter + implicit val implicitPGBufferedImageConverter = PGBufferedImageConverter + implicit val implicitPGURLConverter = PGURLConverter + implicit val implicitPGUUIDConverter = PGUUIDConverter + implicit val implicitPGElemConverter = PGElemConverter + implicit val implicitPGMapConverter = PGMapConverter - implicit val implicitPGOptionStringConverter = PGOptionStringConverter - implicit val implicitPGOptionBooleanConverter = PGOptionBooleanConverter - implicit val implicitPGOptionShortConverter = PGOptionShortConverter - implicit val implicitPGOptionIntConverter = PGOptionIntConverter - implicit val implicitPGOptionLongConverter = PGOptionLongConverter - implicit val implicitPGOptionFloatConverter = PGOptionFloatConverter - implicit val implicitPGOptionDoubleConverter = PGOptionDoubleConverter - implicit val implicitPGOptionBigDecimalConverter = PGOptionBigDecimalConverter - implicit val implicitPGOptionBigIntConverter = PGOptionBigIntConverter - implicit val implicitPGOptionLocalDateConverter = PGOptionLocalDateConverter - implicit val implicitPGOptionDateTimeConverter = PGOptionDateTimeConverter - implicit val implicitPGOptionByteArrayConverter = PGOptionByteArrayConverter - implicit val implicitPGOptionUUIDConverter = PGOptionUUIDConverter - implicit val implicitPGOptionElemConverter = PGOptionElemConverter - implicit val implicitPGOptionMapConverter = PGOptionMapConverter + implicit val implicitPGOptionStringConverter = PGOptionStringConverter + implicit val implicitPGOptionBooleanConverter = PGOptionBooleanConverter + implicit val implicitPGOptionShortConverter = PGOptionShortConverter + implicit val implicitPGOptionIntConverter = PGOptionIntConverter + implicit val implicitPGOptionLongConverter = PGOptionLongConverter + implicit val implicitPGOptionFloatConverter = PGOptionFloatConverter + implicit val implicitPGOptionDoubleConverter = PGOptionDoubleConverter + implicit val implicitPGOptionBigDecimalConverter = PGOptionBigDecimalConverter + implicit val implicitPGOptionBigIntConverter = PGOptionBigIntConverter + implicit val implicitPGOptionLocalDateConverter = PGOptionLocalDateConverter + implicit val implicitPGOptionDateTimeConverter = PGOptionDateTimeConverter + implicit val implicitPGOptionByteArrayConverter = PGOptionByteArrayConverter + implicit val implicitPGOptionBufferedImageConverter = PGOptionBufferedImageConverter + implicit val implicitPGOptionURLConverter = PGOptionURLConverter + implicit val implicitPGOptionUUIDConverter = PGOptionUUIDConverter + implicit val implicitPGOptionElemConverter = PGOptionElemConverter + implicit val implicitPGOptionMapConverter = PGOptionMapConverter } From 3cf228c39c09d40b43b26a9adc73fbc978930c97 Mon Sep 17 00:00:00 2001 From: Ana Marjanica Date: Tue, 30 Dec 2014 15:13:04 +0100 Subject: [PATCH 2/4] location n point converters + unit tests --- .../PGNullableConverterBuilder.scala | 1 + .../PGNullableLocationConverterBuilder.scala | 39 ++++++ .../PGNullablePointConverterBuilder.scala | 18 +-- .../PGNullableLocationConverter.java | 45 +++++++ .../converters/PGNullablePointConverter.java | 21 ++-- .../converters/test/LocationTest.scala | 112 ++++++++++++++++++ .../pgscala/converters/test/PointTest.scala | 81 ++++++------- .../pgscala/converters/PGNullableConverter.j | 20 +++- .../core/PGBufferedImageConverter.scala | 18 +++ .../converters/core/PGURLConverter.scala | 20 ++++ .../PGOptionBufferedImageConverter.scala | 23 ++++ .../option/PGOptionURLConverter.scala | 25 ++++ 12 files changed, 355 insertions(+), 68 deletions(-) create mode 100644 builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilder.scala create mode 100644 converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationConverter.java create mode 100644 converters-java/src/test/scala/org/pgscala/converters/test/LocationTest.scala create mode 100644 converters-scala/src/generated/scala/org/pgscala/converters/core/PGBufferedImageConverter.scala create mode 100644 converters-scala/src/generated/scala/org/pgscala/converters/core/PGURLConverter.scala create mode 100644 converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionBufferedImageConverter.scala create mode 100644 converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionURLConverter.scala diff --git a/builder/src/main/scala/org/pgscala/builder/converters/PGNullableConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/PGNullableConverterBuilder.scala index 7729e89..593cd93 100644 --- a/builder/src/main/scala/org/pgscala/builder/converters/PGNullableConverterBuilder.scala +++ b/builder/src/main/scala/org/pgscala/builder/converters/PGNullableConverterBuilder.scala @@ -148,6 +148,7 @@ object PGNullableConverterBuilder extends PGConverterBuilderPaths { , PGNullableElemConverterBuilder , PGNullableMapConverterBuilder + , PGNullableLocationConverterBuilder , PGNullablePointConverterBuilder ) diff --git a/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilder.scala new file mode 100644 index 0000000..7dc0fc8 --- /dev/null +++ b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilder.scala @@ -0,0 +1,39 @@ +package org.pgscala +package builder +package converters + +object PGNullableLocationConverterBuilder extends PGPredefNullableConverterBuilder { + val pgType = "point" + + val clazz = "java.awt.geom.Point2D" + + override val upperType = "Location" + override def javaType = clazz + + override val body = """ + private static Double getDoubleFromString(String s) { + if (s.equals("nan")) + return Double.NaN; + else if (s.equals("inf")) + return Double.POSITIVE_INFINITY; + else if (s.equals("-inf")) + return Double.NEGATIVE_INFINITY; + else + return Double.valueOf(s); + } + """ + + val to = """return "("+ l.getX()+","+l.getY()+")"""" + + val from = """ + double x = getDoubleFromString(l.substring(1, l.indexOf(","))); + double y = getDoubleFromString(l.substring(l.indexOf(",")+1, l.length()-1)); + return new java.awt.geom.Point2D.Double(x, y)""" + + override def inject(body: String) = + super.inject(body) + .replace( + "return null == l ? null :" + , "if (null == l) return null;") +} + diff --git a/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullablePointConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullablePointConverterBuilder.scala index 79a8d68..884e9e1 100644 --- a/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullablePointConverterBuilder.scala +++ b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullablePointConverterBuilder.scala @@ -5,23 +5,23 @@ package converters object PGNullablePointConverterBuilder extends PGPredefNullableConverterBuilder { val pgType = "point" - val clazz = "java.awt.geom.Point2D" + val clazz = "java.awt.Point" override val upperType = "Point" override def javaType = clazz - - val to = """return "("+ p.getX()+","+p.getY()+")"""" + + val to = """return "("+ (int) p.getX()+","+ (int) p.getY()+")"""" val from = """ - double x = Double.valueOf(p.substring(1, p.indexOf(","))); - double y = Double.valueOf(p.substring(p.indexOf(",")+1, p.length()-1)); - return new java.awt.geom.Point2D.Double(x, y)""" + if (p.indexOf("nan")!=-1 ||p.indexOf("inf")!=-1) return null; + int x = Integer.valueOf(p.substring(1, p.indexOf(","))); + int y = Integer.valueOf(p.substring(p.indexOf(",")+1, p.length()-1)); + return new java.awt.Point(x, y)""" override def inject(body: String) = super.inject(body) .replace( - "return null == p ? null :", - """if (null == p) return null; - """) + "return null == p ? null :" + , "if (null == p) return null;") } diff --git a/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationConverter.java b/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationConverter.java new file mode 100644 index 0000000..e672fdc --- /dev/null +++ b/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationConverter.java @@ -0,0 +1,45 @@ +package org.pgscala.converters; + +import org.joda.convert.*; + +/** Do not edit - generated in Builder / PGNullableLocationConverterBuilder.scala */ + +public enum PGNullableLocationConverter implements StringConverter { + INSTANCE; + + public static final String pgType = "point"; + + private static Double getDoubleFromString(String s) { + if (s.equals("nan")) + return Double.NaN; + else if (s.equals("inf")) + return Double.POSITIVE_INFINITY; + else if (s.equals("-inf")) + return Double.NEGATIVE_INFINITY; + else + return Double.valueOf(s); + } + + @ToString + public static String locationToString(final java.awt.geom.Point2D l) { + if (null == l) return null; return "("+ l.getX()+","+l.getY()+")"; + } + + @FromString + public static java.awt.geom.Point2D stringToLocation(final String l) { + if (null == l) return null; + double x = getDoubleFromString(l.substring(1, l.indexOf(","))); + double y = getDoubleFromString(l.substring(l.indexOf(",")+1, l.length()-1)); + return new java.awt.geom.Point2D.Double(x, y); + } + +// ----------------------------------------------------------------------------- + + public String convertToString(final java.awt.geom.Point2D l) { + return locationToString(l); + } + + public java.awt.geom.Point2D convertFromString(final Class clazz, final String l) { + return stringToLocation(l); + } +} diff --git a/converters-java/src/generated/java/org/pgscala/converters/PGNullablePointConverter.java b/converters-java/src/generated/java/org/pgscala/converters/PGNullablePointConverter.java index 6f60f49..0e39da9 100644 --- a/converters-java/src/generated/java/org/pgscala/converters/PGNullablePointConverter.java +++ b/converters-java/src/generated/java/org/pgscala/converters/PGNullablePointConverter.java @@ -4,33 +4,32 @@ /** Do not edit - generated in Builder / PGNullablePointConverterBuilder.scala */ -public enum PGNullablePointConverter implements StringConverter { +public enum PGNullablePointConverter implements StringConverter { INSTANCE; public static final String pgType = "point"; @ToString - public static String pointToString(final java.awt.geom.Point2D p) { - if (null == p) return null; - return "("+ p.getX()+","+p.getY()+")"; + public static String pointToString(final java.awt.Point p) { + if (null == p) return null; return "("+ (int) p.getX()+","+ (int) p.getY()+")"; } @FromString - public static java.awt.geom.Point2D stringToPoint(final String p) { + public static java.awt.Point stringToPoint(final String p) { if (null == p) return null; - - double x = Double.valueOf(p.substring(1, p.indexOf(","))); - double y = Double.valueOf(p.substring(p.indexOf(",")+1, p.length()-1)); - return new java.awt.geom.Point2D.Double(x, y); + if (p.indexOf("nan")!=-1 ||p.indexOf("inf")!=-1) return null; + int x = Integer.valueOf(p.substring(1, p.indexOf(","))); + int y = Integer.valueOf(p.substring(p.indexOf(",")+1, p.length()-1)); + return new java.awt.Point(x, y); } // ----------------------------------------------------------------------------- - public String convertToString(final java.awt.geom.Point2D p) { + public String convertToString(final java.awt.Point p) { return pointToString(p); } - public java.awt.geom.Point2D convertFromString(final Class clazz, final String p) { + public java.awt.Point convertFromString(final Class clazz, final String p) { return stringToPoint(p); } } diff --git a/converters-java/src/test/scala/org/pgscala/converters/test/LocationTest.scala b/converters-java/src/test/scala/org/pgscala/converters/test/LocationTest.scala new file mode 100644 index 0000000..880e0c2 --- /dev/null +++ b/converters-java/src/test/scala/org/pgscala/converters/test/LocationTest.scala @@ -0,0 +1,112 @@ +package org.pgscala.converters +package test + +import org.junit.runner.RunWith +import org.scalatest.junit.JUnitRunner +import org.scalatest.FeatureSpec +import org.scalatest.GivenWhenThen +import org.scalatest.Matchers + +@RunWith(classOf[JUnitRunner]) +class LocationTest extends FeatureSpec with GivenWhenThen with Matchers { + feature("About to test an Location converter") { + info("I want to test if PGNullableLocationConverter works correctly, both in 2 way conversion") + info("I am going to perform tests for the Point boundary cases") + + scenario("Double Point to String Nr. 1") { + Given("a starting Point(Double.Min, Double.MaxValue)") + val p = new java.awt.geom.Point2D.Double(Double.MaxValue, Double.MinValue); + val res = PGNullableLocationConverter locationToString p + When(s"that value is converted to String $res") + val expectedResult = s"(${Double.MaxValue.toDouble},${Double.MinValue.toDouble})" + Then(s"It should return a String value $expectedResult") + res should equal(expectedResult) + } + + scenario("Double Point to String Nr. 2") { + Given("a starting Point(Double.NaN, Double.NaN)") + val p = new java.awt.geom.Point2D.Double(Double.NaN, Double.NaN); + When("that value is converted to String") + val res = PGNullableLocationConverter locationToString p + val expectedResult = s"(${Double.NaN},${Double.NaN})" + Then(s"It should return a String value $expectedResult") + res should equal(expectedResult) + } + + scenario("Double Point to String Nr. 3") { + Given("a starting Point(0,0)") + val p = new java.awt.geom.Point2D.Double(0, 0); + val res = PGNullableLocationConverter locationToString p + When(s"that value is converted to String $res") + val expectedResult = "(0.0,0.0)" + Then(s"It should return a String value $expectedResult") + res should equal(expectedResult) + } + + scenario("Double Point to String Nr. 4") { + Given("a starting Point(Double.PositiveInfinity, Double.NegativeInfinity)") + val p = new java.awt.geom.Point2D.Double(Double.PositiveInfinity, Double.NegativeInfinity); + When("that value is converted to String") + val res = PGNullableLocationConverter locationToString p + val expectedResult = s"(${Double.PositiveInfinity},${Double.NegativeInfinity})" + Then(s"It should return a String value $expectedResult") + res should equal(expectedResult) + } + + scenario("String to Point Nr. 1") { + val given = "(9.9999999999999991e-308,1e+308)" + Given(s"a starting String: $given") + val res = PGNullableLocationConverter stringToLocation given + When(s"that value is converted to String $res") + val expectedResult = new java.awt.geom.Point2D.Double(1E-307, 1E+308); + Then(s"It should return a Point $expectedResult") + res should equal(expectedResult) + } + + scenario("String to Point Nr. 2") { + val given = "(nan,nan)" + Given(s"a starting String: $given") + val res = PGNullableLocationConverter stringToLocation(given) + When(s"that value is converted to String $res") + val expectedResult = new java.awt.geom.Point2D.Double(Double.NaN, Double.NaN); + Then(s"It should return a Point value $expectedResult") + res.getX.isNaN && res.getY.isNaN should be(true) + } + + scenario("String to Point Nr. 3") { + val given = "(0,0)" + Given(s"a starting String: $given") + val res = PGNullableLocationConverter stringToLocation given + When(s"that value is converted to String $res") + val expectedResult = new java.awt.geom.Point2D.Double(0, 0) + Then(s"It should return a String value $expectedResult") + res should equal(expectedResult) + } + + scenario("String to Point Nr. 4") { + val given = "(inf,-inf)" + Given(s"a starting String: $given") + val res = PGNullableLocationConverter stringToLocation(given) + When(s"that value is converted to String $res") + val expectedResult = new java.awt.geom.Point2D.Double(Double.PositiveInfinity, Double.NegativeInfinity); + Then(s"It should return a Point value $expectedResult") + res should equal(expectedResult) + } + + scenario("Int to Double and Double To Int") { + val total = 100000 + Given(s"A random set of $total integers ") + + Then("Then double->integer and integer<- double must not fail!") + for (num <- 0 until total) { + val rndNum = scala.util.Random.nextInt() + val doubleFromInt = rndNum.toDouble +// println(doubleFromInt.toInt, rndNum) + doubleFromInt.toInt should equal(rndNum) +// println(rndNum, doubleFromInt) + rndNum should equal(doubleFromInt) + } + + } + } +} diff --git a/converters-java/src/test/scala/org/pgscala/converters/test/PointTest.scala b/converters-java/src/test/scala/org/pgscala/converters/test/PointTest.scala index ba918ad..8b254c0 100644 --- a/converters-java/src/test/scala/org/pgscala/converters/test/PointTest.scala +++ b/converters-java/src/test/scala/org/pgscala/converters/test/PointTest.scala @@ -13,88 +13,77 @@ class PointTest extends FeatureSpec with GivenWhenThen with Matchers { info("I want to test if PGNullablePointConverter works correctly, both in 2 way conversion") info("I am going to perform tests for the Point boundary cases") - scenario("Double Point to String Nr. 1") { - Given("a starting Point(Double.Min, Double.MaxValue)") - val p = new java.awt.geom.Point2D.Double(Double.MaxValue, Double.MinValue); + scenario("java.awt.Point to String Nr. 1") { + Given("a starting Point(Int.Min, Int.MaxValue)") + val p = new java.awt.Point(Int.MaxValue, Int.MinValue); val res = PGNullablePointConverter pointToString p When(s"that value is converted to String $res") - val expectedResult = s"(${Double.MaxValue.toDouble},${Double.MinValue.toDouble})" + val expectedResult = s"(${Int.MaxValue},${Int.MinValue})" Then(s"It should return a String value $expectedResult") res should equal(expectedResult) } - - scenario("Double Point to String Nr. 2") { - Given("a starting Point(Double.NaN, Double.NaN)") - val p = new java.awt.geom.Point2D.Double(Double.NaN, Double.NaN); - When("that value is converted to String") - val res = PGNullablePointConverter pointToString p - val expectedResult = s"(${Double.NaN},${Double.NaN})" - Then(s"It should return a String value $expectedResult") - res should equal(expectedResult) - } - scenario("Double Point to String Nr. 3") { + + scenario("Integer Point to String Nr. 2") { Given("a starting Point(0,0)") - val p = new java.awt.geom.Point2D.Double(0, 0); + val p = new java.awt.Point(0, 0); val res = PGNullablePointConverter pointToString p When(s"that value is converted to String $res") - val expectedResult = s"(${0d},${0d})" + val expectedResult = "(0,0)" Then(s"It should return a String value $expectedResult") res should equal(expectedResult) } - - scenario("Double Point to String Nr. 4") { - Given("a starting Point(Double.PositiveInfinity, Double.NegativeInfinity)") - val p = new java.awt.geom.Point2D.Double(Double.PositiveInfinity, Double.NegativeInfinity); - When("that value is converted to String") + + scenario("Integer Point to String Nr. 3") { + Given("a starting Point of random integers...") + val x = scala.util.Random.nextInt + val y = scala.util.Random.nextInt + val p = new java.awt.Point(x, y); val res = PGNullablePointConverter pointToString p - val expectedResult = s"(${Double.PositiveInfinity},${Double.NegativeInfinity})" + When(s"that value is converted to String: $res") + val expectedResult = s"(${x},${y})" Then(s"It should return a String value $expectedResult") res should equal(expectedResult) - } - -// scenario("Db test Nr. 1") { -// PGTestDb. -// } - + } + scenario("String to Point Nr. 1") { - Given("a starting String (Double.Min, Double.MaxValue)") - val given = s"(${Double.MaxValue.toDouble},${Double.MinValue.toDouble})" + val given = "(2147483647,-2147483648)" + Given(s"a starting String: $given") val res = PGNullablePointConverter stringToPoint given When(s"that value is converted to String $res") - val expectedResult = new java.awt.geom.Point2D.Double(Double.MaxValue, Double.MinValue); + val expectedResult = new java.awt.Point(2147483647, -2147483648); Then(s"It should return a Point $expectedResult") res should equal(expectedResult) } - + scenario("String to Point Nr. 2") { - Given("a starting String (Double.NaN, Double.NaN)") - val given = s"(${Double.NaN},${Double.NaN})" + val given = "(nan,nan)" + Given(s"a starting String: $given") val res = PGNullablePointConverter stringToPoint(given) When(s"that value is converted to String $res") - val expectedResult = new java.awt.geom.Point2D.Double(Double.NaN, Double.NaN); + val expectedResult = null; Then(s"It should return a Point value $expectedResult") - res should equal(expectedResult) - } + res should be(null) + } scenario("String to Point Nr. 3") { - Given("a starting Point(0,0)") - val given = s"(${0d},${0d})" + val given = "(0,0)" + Given(s"a starting String: $given") val res = PGNullablePointConverter stringToPoint given When(s"that value is converted to String $res") - val expectedResult = new java.awt.geom.Point2D.Double(0, 0) + val expectedResult = new java.awt.Point(0, 0) Then(s"It should return a String value $expectedResult") res should equal(expectedResult) } - + scenario("String to Point Nr. 4") { - Given("a starting Point(Double.PositiveInfinity, Double.NegativeInfinity)") - val given = s"(${Double.PositiveInfinity},${Double.NegativeInfinity})" + val given = "(inf,-inf)" + Given(s"a starting String: $given") val res = PGNullablePointConverter stringToPoint(given) When(s"that value is converted to String $res") - val expectedResult = new java.awt.geom.Point2D.Double(Double.PositiveInfinity, Double.NegativeInfinity); + val expectedResult = null; Then(s"It should return a Point value $expectedResult") res should equal(expectedResult) - } + } } } diff --git a/converters-scala/src/generated/jasmin/org/pgscala/converters/PGNullableConverter.j b/converters-scala/src/generated/jasmin/org/pgscala/converters/PGNullableConverter.j index 7fec67d..3c792b3 100644 --- a/converters-scala/src/generated/jasmin/org/pgscala/converters/PGNullableConverter.j +++ b/converters-scala/src/generated/jasmin/org/pgscala/converters/PGNullableConverter.j @@ -265,7 +265,7 @@ .limit locals 1 .limit stack 2 aload_0 - invokestatic org/pgscala/converters/PGNullablePointConverter.stringToPoint(Ljava/lang/String;)Ljava/awt/geom/Point2D; + invokestatic org/pgscala/converters/PGNullableLocationConverter.stringToLocation(Ljava/lang/String;)Ljava/awt/geom/Point2D; areturn .end method @@ -273,6 +273,22 @@ .limit locals 1 .limit stack 2 aload_0 - invokestatic org/pgscala/converters/PGNullablePointConverter.pointToString(Ljava/awt/geom/Point2D;)Ljava/lang/String; + invokestatic org/pgscala/converters/PGNullableLocationConverter.locationToString(Ljava/awt/geom/Point2D;)Ljava/lang/String; + areturn +.end method + +.method public static fromPGString(Ljava/lang/String;)Ljava/awt/Point; + .limit locals 1 + .limit stack 2 + aload_0 + invokestatic org/pgscala/converters/PGNullablePointConverter.stringToPoint(Ljava/lang/String;)Ljava/awt/Point; + areturn +.end method + +.method public static toPGString(Ljava/awt/Point;)Ljava/lang/String; + .limit locals 1 + .limit stack 2 + aload_0 + invokestatic org/pgscala/converters/PGNullablePointConverter.pointToString(Ljava/awt/Point;)Ljava/lang/String; areturn .end method diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/core/PGBufferedImageConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGBufferedImageConverter.scala new file mode 100644 index 0000000..7c8c1e8 --- /dev/null +++ b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGBufferedImageConverter.scala @@ -0,0 +1,18 @@ +package org.pgscala.converters + +/** Do not edit - generated in Builder / PGBufferedImageConverterBuilder.scala */ + +object PGBufferedImageConverter extends PGConverter[BufferedImage] { + val PGType = PGNullableBufferedImageConverter.pgType + + def toPGString(bi: BufferedImage) = + PGNullableBufferedImageConverter.bufferedImageToString(bi) + + val defaultValue: BufferedImage = new java.awt.image.BufferedImage(1, 1, java.awt.image.BufferedImage.TYPE_4BYTE_ABGR) + + def fromPGString(bi: String) = + if (bi eq null) + defaultValue + else + PGNullableBufferedImageConverter.stringToBufferedImage(bi) +} diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/core/PGURLConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGURLConverter.scala new file mode 100644 index 0000000..798738f --- /dev/null +++ b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGURLConverter.scala @@ -0,0 +1,20 @@ +package org.pgscala.converters + +import java.net.URL + +/** Do not edit - generated in Builder / PGURLConverterBuilder.scala */ + +object PGURLConverter extends PGConverter[URL] { + val PGType = PGNullableURLConverter.pgType + + def toPGString(url: URL) = + PGNullableURLConverter.urlToString(url) + + val defaultValue: URL = null + + def fromPGString(url: String) = + if (url eq null) + defaultValue + else + PGNullableURLConverter.stringToURL(url) +} diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionBufferedImageConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionBufferedImageConverter.scala new file mode 100644 index 0000000..00bb47c --- /dev/null +++ b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionBufferedImageConverter.scala @@ -0,0 +1,23 @@ +package org.pgscala.converters + +/** Do not edit - generated in Builder / PGBufferedImageConverterBuilder.scala */ + +object PGOptionBufferedImageConverter extends PGConverter[Option[BufferedImage]] { + val PGType = PGBufferedImageConverter.PGType + + def toPGString(obi: Option[BufferedImage]): String = + obi match { + case None => + null + case Some(bi) => + PGBufferedImageConverter.toPGString(bi) + } + + def fromPGString(bi: String): Option[BufferedImage] = + bi match { + case null | "" => + None + case obi => + Some(PGBufferedImageConverter.fromPGString(obi)) + } +} diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionURLConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionURLConverter.scala new file mode 100644 index 0000000..34681b7 --- /dev/null +++ b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionURLConverter.scala @@ -0,0 +1,25 @@ +package org.pgscala.converters + +import java.net.URL + +/** Do not edit - generated in Builder / PGURLConverterBuilder.scala */ + +object PGOptionURLConverter extends PGConverter[Option[URL]] { + val PGType = PGURLConverter.PGType + + def toPGString(ourl: Option[URL]): String = + ourl match { + case None => + null + case Some(url) => + PGURLConverter.toPGString(url) + } + + def fromPGString(url: String): Option[URL] = + url match { + case null | "" => + None + case ourl => + Some(PGURLConverter.fromPGString(ourl)) + } +} From 6454678cfcf99404c5c8cebf06b6c48c32df0726 Mon Sep 17 00:00:00 2001 From: Ana Marjanica Date: Tue, 30 Dec 2014 16:51:41 +0100 Subject: [PATCH 3/4] fix for scala buffered image builder added scala location, point converters todo: write more loc, point integration tests... --- .../converters/PGConverterBuilder.scala | 3 +++ .../scala/PGBufferedImageConverter.scala | 1 + .../scala/PGLocationConverterBuilder.scala | 16 +++++++++++++ .../scala/PGPointConverterBuilder.scala | 17 ++++++++++++++ .../org/pgscala/converters/Implicits.scala | 4 ++++ .../core/PGBufferedImageConverter.scala | 2 +- .../converters/core/PGLocationConverter.scala | 18 +++++++++++++++ .../converters/core/PGPointConverter.scala | 18 +++++++++++++++ .../PGOptionBufferedImageConverter.scala | 2 +- .../option/PGOptionLocationConverter.scala | 23 +++++++++++++++++++ .../option/PGOptionPointConverter.scala | 23 +++++++++++++++++++ .../org/pgscala/test/PGScalaFeatureSpec.scala | 5 ++++ 12 files changed, 130 insertions(+), 2 deletions(-) create mode 100644 builder/src/main/scala/org/pgscala/builder/converters/scala/PGLocationConverterBuilder.scala create mode 100644 builder/src/main/scala/org/pgscala/builder/converters/scala/PGPointConverterBuilder.scala create mode 100644 converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationConverter.scala create mode 100644 converters-scala/src/generated/scala/org/pgscala/converters/core/PGPointConverter.scala create mode 100644 converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationConverter.scala create mode 100644 converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionPointConverter.scala diff --git a/builder/src/main/scala/org/pgscala/builder/converters/PGConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/PGConverterBuilder.scala index 79f90a4..92fbbf9 100644 --- a/builder/src/main/scala/org/pgscala/builder/converters/PGConverterBuilder.scala +++ b/builder/src/main/scala/org/pgscala/builder/converters/PGConverterBuilder.scala @@ -116,6 +116,9 @@ object PGConverterBuilder extends PGConverterBuilderPaths { , PGElemConverterBuilder , PGMapConverterBuilder + + , PGLocationConverterBuilder + , PGPointConverterBuilder ) def buildScalaConverters() { diff --git a/builder/src/main/scala/org/pgscala/builder/converters/scala/PGBufferedImageConverter.scala b/builder/src/main/scala/org/pgscala/builder/converters/scala/PGBufferedImageConverter.scala index b6394fd..6a1affb 100644 --- a/builder/src/main/scala/org/pgscala/builder/converters/scala/PGBufferedImageConverter.scala +++ b/builder/src/main/scala/org/pgscala/builder/converters/scala/PGBufferedImageConverter.scala @@ -4,6 +4,7 @@ package converters object PGBufferedImageConverterBuilder extends PGConverterBuilder { + override def imports = "import java.awt.image.BufferedImage" val scalaClazz = "java.awt.image.BufferedImage" diff --git a/builder/src/main/scala/org/pgscala/builder/converters/scala/PGLocationConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/scala/PGLocationConverterBuilder.scala new file mode 100644 index 0000000..96f55dd --- /dev/null +++ b/builder/src/main/scala/org/pgscala/builder/converters/scala/PGLocationConverterBuilder.scala @@ -0,0 +1,16 @@ +package org.pgscala +package builder +package converters + +object PGLocationConverterBuilder + extends PGConverterBuilder { + + override def imports = "import java.awt.geom._" + override val scalaUpperType = "Location" + + override val javaUpperType = "Location" + + val scalaClazz = "java.awt.geom.Point2D" + + val defaultValue = """new java.awt.geom.Point2D.Double()""" +} diff --git a/builder/src/main/scala/org/pgscala/builder/converters/scala/PGPointConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/scala/PGPointConverterBuilder.scala new file mode 100644 index 0000000..408b3df --- /dev/null +++ b/builder/src/main/scala/org/pgscala/builder/converters/scala/PGPointConverterBuilder.scala @@ -0,0 +1,17 @@ +package org.pgscala +package builder +package converters + +object PGPointConverterBuilder + extends PGConverterBuilder { + + override def imports = "import java.awt._" + + override val scalaUpperType = "Point" + + override val javaUpperType = "Point" + + val scalaClazz = "java.awt.Point" + + val defaultValue = """new java.awt.Point()""" +} diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala b/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala index 1b98e10..9e25450 100644 --- a/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala +++ b/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala @@ -18,6 +18,8 @@ trait Implicits { implicit val implicitPGUUIDConverter = PGUUIDConverter implicit val implicitPGElemConverter = PGElemConverter implicit val implicitPGMapConverter = PGMapConverter + implicit val implicitPGLocationConverter = PGLocationConverter + implicit val implicitPGPointConverter = PGPointConverter implicit val implicitPGOptionStringConverter = PGOptionStringConverter implicit val implicitPGOptionBooleanConverter = PGOptionBooleanConverter @@ -36,4 +38,6 @@ trait Implicits { implicit val implicitPGOptionUUIDConverter = PGOptionUUIDConverter implicit val implicitPGOptionElemConverter = PGOptionElemConverter implicit val implicitPGOptionMapConverter = PGOptionMapConverter + implicit val implicitPGOptionLocationConverter = PGOptionLocationConverter + implicit val implicitPGOptionPointConverter = PGOptionPointConverter } diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/core/PGBufferedImageConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGBufferedImageConverter.scala index 7c8c1e8..d29a6b6 100644 --- a/converters-scala/src/generated/scala/org/pgscala/converters/core/PGBufferedImageConverter.scala +++ b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGBufferedImageConverter.scala @@ -1,5 +1,5 @@ package org.pgscala.converters - +import java.awt.image.BufferedImage /** Do not edit - generated in Builder / PGBufferedImageConverterBuilder.scala */ object PGBufferedImageConverter extends PGConverter[BufferedImage] { diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationConverter.scala new file mode 100644 index 0000000..911d20d --- /dev/null +++ b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationConverter.scala @@ -0,0 +1,18 @@ +package org.pgscala.converters +import java.awt.geom._ +/** Do not edit - generated in Builder / PGLocationConverterBuilder.scala */ + +object PGLocationConverter extends PGConverter[Point2D] { + val PGType = PGNullableLocationConverter.pgType + + def toPGString(l: Point2D) = + PGNullableLocationConverter.locationToString(l) + + val defaultValue: Point2D = new java.awt.geom.Point2D.Double() + + def fromPGString(l: String) = + if (l eq null) + defaultValue + else + PGNullableLocationConverter.stringToLocation(l) +} diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/core/PGPointConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGPointConverter.scala new file mode 100644 index 0000000..f67bff7 --- /dev/null +++ b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGPointConverter.scala @@ -0,0 +1,18 @@ +package org.pgscala.converters +import java.awt._ +/** Do not edit - generated in Builder / PGPointConverterBuilder.scala */ + +object PGPointConverter extends PGConverter[Point] { + val PGType = PGNullablePointConverter.pgType + + def toPGString(p: Point) = + PGNullablePointConverter.pointToString(p) + + val defaultValue: Point = new java.awt.Point() + + def fromPGString(p: String) = + if (p eq null) + defaultValue + else + PGNullablePointConverter.stringToPoint(p) +} diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionBufferedImageConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionBufferedImageConverter.scala index 00bb47c..468b818 100644 --- a/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionBufferedImageConverter.scala +++ b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionBufferedImageConverter.scala @@ -1,5 +1,5 @@ package org.pgscala.converters - +import java.awt.image.BufferedImage /** Do not edit - generated in Builder / PGBufferedImageConverterBuilder.scala */ object PGOptionBufferedImageConverter extends PGConverter[Option[BufferedImage]] { diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationConverter.scala new file mode 100644 index 0000000..1f7133c --- /dev/null +++ b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationConverter.scala @@ -0,0 +1,23 @@ +package org.pgscala.converters +import java.awt.geom._ +/** Do not edit - generated in Builder / PGLocationConverterBuilder.scala */ + +object PGOptionLocationConverter extends PGConverter[Option[Point2D]] { + val PGType = PGLocationConverter.PGType + + def toPGString(ol: Option[Point2D]): String = + ol match { + case None => + null + case Some(l) => + PGLocationConverter.toPGString(l) + } + + def fromPGString(l: String): Option[Point2D] = + l match { + case null | "" => + None + case ol => + Some(PGLocationConverter.fromPGString(ol)) + } +} diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionPointConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionPointConverter.scala new file mode 100644 index 0000000..0b69ef5 --- /dev/null +++ b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionPointConverter.scala @@ -0,0 +1,23 @@ +package org.pgscala.converters +import java.awt._ +/** Do not edit - generated in Builder / PGPointConverterBuilder.scala */ + +object PGOptionPointConverter extends PGConverter[Option[Point]] { + val PGType = PGPointConverter.PGType + + def toPGString(op: Option[Point]): String = + op match { + case None => + null + case Some(p) => + PGPointConverter.toPGString(p) + } + + def fromPGString(p: String): Option[Point] = + p match { + case null | "" => + None + case op => + Some(PGPointConverter.fromPGString(op)) + } +} diff --git a/pgscala/src/test/scala/org/pgscala/test/PGScalaFeatureSpec.scala b/pgscala/src/test/scala/org/pgscala/test/PGScalaFeatureSpec.scala index 1cb81c8..41e2746 100644 --- a/pgscala/src/test/scala/org/pgscala/test/PGScalaFeatureSpec.scala +++ b/pgscala/src/test/scala/org/pgscala/test/PGScalaFeatureSpec.scala @@ -19,5 +19,10 @@ class PGScalaFeatureSpec extends FeatureSpec with GivenWhenThen with Matchers { using(_.get[BigDecimal]("SELECT @1;", bd)) should === (bd) using(_.get[BigDecimal]("SELECT $1;", bd)) should === (bd) } + + scenario("Point test"){ + val p = new java.awt.Point(0, 0) + using(_.get[java.awt.Point]("SELECT @1;", p)) should === (p) + } } } From d252d339f7491b5b3af751dd96d2d2c595648115 Mon Sep 17 00:00:00 2001 From: Ana Marjanica Date: Wed, 31 Dec 2014 12:44:43 +0100 Subject: [PATCH 4/4] extracted location builder to location, double and float reason: for scala implicit conversions integration location and point tests successful double converter tests (failing min value) --- .../converters/PGConverterBuilder.scala | 2 +- .../PGNullableConverterBuilder.scala | 3 +- .../PGNullableLocationConverterBuilder.scala | 35 +-------- ...NullableLocationConverterBuilderLike.scala | 54 +++++++++++++ ...llableLocationDoubleConverterBuilder.scala | 9 +++ ...ullableLocationFloatConverterBuilder.scala | 29 +++++++ .../scala/PGLocationConverterBuilder.scala | 16 ---- .../PGLocationDoubleConverterBuilder.scala | 17 +++++ .../PGNullableLocationConverter.java | 13 +++- .../PGNullableLocationDoubleConverter.java | 56 ++++++++++++++ .../PGNullableLocationFloatConverter.java | 56 ++++++++++++++ .../converters/test/LocationTest.scala | 4 +- .../pgscala/converters/PGNullableConverter.j | 32 ++++++++ .../org/pgscala/converters/Implicits.scala | 76 +++++++++---------- .../converters/core/PGLocationConverter.scala | 10 +-- .../core/PGLocationDoubleConverter.scala | 18 +++++ .../option/PGOptionLocationConverter.scala | 6 +- .../PGOptionLocationDoubleConverter.scala | 23 ++++++ .../pgscala/test/PGDoubleFeatureSpec.scala | 42 ++++++++++ .../pgscala/test/PGLocationFeatureSpec.scala | 71 +++++++++++++++++ .../org/pgscala/test/PGPointFeatureSpec.scala | 40 ++++++++++ .../org/pgscala/test/PGScalaFeatureSpec.scala | 5 -- 22 files changed, 511 insertions(+), 106 deletions(-) create mode 100644 builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilderLike.scala create mode 100644 builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationDoubleConverterBuilder.scala create mode 100644 builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationFloatConverterBuilder.scala delete mode 100644 builder/src/main/scala/org/pgscala/builder/converters/scala/PGLocationConverterBuilder.scala create mode 100644 builder/src/main/scala/org/pgscala/builder/converters/scala/PGLocationDoubleConverterBuilder.scala create mode 100644 converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationDoubleConverter.java create mode 100644 converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationFloatConverter.java create mode 100644 converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationDoubleConverter.scala create mode 100644 converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationDoubleConverter.scala create mode 100644 pgscala/src/test/scala/org/pgscala/test/PGDoubleFeatureSpec.scala create mode 100644 pgscala/src/test/scala/org/pgscala/test/PGLocationFeatureSpec.scala create mode 100644 pgscala/src/test/scala/org/pgscala/test/PGPointFeatureSpec.scala diff --git a/builder/src/main/scala/org/pgscala/builder/converters/PGConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/PGConverterBuilder.scala index 92fbbf9..e09a193 100644 --- a/builder/src/main/scala/org/pgscala/builder/converters/PGConverterBuilder.scala +++ b/builder/src/main/scala/org/pgscala/builder/converters/PGConverterBuilder.scala @@ -117,7 +117,7 @@ object PGConverterBuilder extends PGConverterBuilderPaths { , PGElemConverterBuilder , PGMapConverterBuilder - , PGLocationConverterBuilder + , PGLocationDoubleConverterBuilder , PGPointConverterBuilder ) diff --git a/builder/src/main/scala/org/pgscala/builder/converters/PGNullableConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/PGNullableConverterBuilder.scala index 593cd93..c948108 100644 --- a/builder/src/main/scala/org/pgscala/builder/converters/PGNullableConverterBuilder.scala +++ b/builder/src/main/scala/org/pgscala/builder/converters/PGNullableConverterBuilder.scala @@ -147,8 +147,9 @@ object PGNullableConverterBuilder extends PGConverterBuilderPaths { , PGNullableElemConverterBuilder , PGNullableMapConverterBuilder - , PGNullableLocationConverterBuilder + , PGNullableLocationDoubleConverterBuilder + , PGNullableLocationFloatConverterBuilder , PGNullablePointConverterBuilder ) diff --git a/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilder.scala index 7dc0fc8..28fa91d 100644 --- a/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilder.scala +++ b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilder.scala @@ -2,38 +2,5 @@ package org.pgscala package builder package converters -object PGNullableLocationConverterBuilder extends PGPredefNullableConverterBuilder { - val pgType = "point" - - val clazz = "java.awt.geom.Point2D" - - override val upperType = "Location" - override def javaType = clazz - - override val body = """ - private static Double getDoubleFromString(String s) { - if (s.equals("nan")) - return Double.NaN; - else if (s.equals("inf")) - return Double.POSITIVE_INFINITY; - else if (s.equals("-inf")) - return Double.NEGATIVE_INFINITY; - else - return Double.valueOf(s); - } - """ - - val to = """return "("+ l.getX()+","+l.getY()+")"""" - - val from = """ - double x = getDoubleFromString(l.substring(1, l.indexOf(","))); - double y = getDoubleFromString(l.substring(l.indexOf(",")+1, l.length()-1)); - return new java.awt.geom.Point2D.Double(x, y)""" - - override def inject(body: String) = - super.inject(body) - .replace( - "return null == l ? null :" - , "if (null == l) return null;") -} +object PGNullableLocationConverterBuilder extends PGNullableLocationConverterBuilderLike diff --git a/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilderLike.scala b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilderLike.scala new file mode 100644 index 0000000..481f3fa --- /dev/null +++ b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilderLike.scala @@ -0,0 +1,54 @@ +package org.pgscala +package builder +package converters + +trait PGNullableLocationConverterBuilderLike extends PGPredefNullableConverterBuilder { + val pgType = "point" + + val clazz = "java.awt.geom.Point2D" + + override val upperType = "Location" + override def javaType = clazz + override val javaVar = "l" + + protected var commonMethods = """ + private static String getStringFromDouble(Double s) { + if (s.isNaN()) + return "nan"; + else if (s == Double.POSITIVE_INFINITY) + return "inf"; + else if (s == Double.NEGATIVE_INFINITY) + return "-inf"; + else + return String.valueOf(s); + } + """ + override val body = s""" + private static Double getDoubleFromString(String s) { + if (s.equals("nan")) + return Double.NaN; + else if (s.equals("inf")) + return Double.POSITIVE_INFINITY; + else if (s.equals("-inf")) + return Double.NEGATIVE_INFINITY; + else + return Double.valueOf(s); + } + + ${commonMethods} + """ + + val to = """return "("+ getStringFromDouble(l.getX())+","+getStringFromDouble(l.getY())+")"""" + + val from = """ + double x = getDoubleFromString(l.substring(1, l.indexOf(","))); + double y = getDoubleFromString(l.substring(l.indexOf(",")+1, l.length()-1)); + return new java.awt.geom.Point2D.Double(x, y)""" + + override def inject(body: String) = + super.inject(body) + .replace( + "return null == l ? null :" + , "if (null == l) return null;") +} + diff --git a/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationDoubleConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationDoubleConverterBuilder.scala new file mode 100644 index 0000000..8af0fa5 --- /dev/null +++ b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationDoubleConverterBuilder.scala @@ -0,0 +1,9 @@ +package org.pgscala +package builder +package converters + +object PGNullableLocationDoubleConverterBuilder extends PGNullableLocationConverterBuilderLike { + override val clazz = "java.awt.geom.Point2D.Double" + override val upperType = "LocationDouble" +} + diff --git a/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationFloatConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationFloatConverterBuilder.scala new file mode 100644 index 0000000..5327207 --- /dev/null +++ b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationFloatConverterBuilder.scala @@ -0,0 +1,29 @@ +package org.pgscala +package builder +package converters + +object PGNullableLocationFloatConverterBuilder extends PGNullableLocationConverterBuilderLike { + override val clazz = "java.awt.geom.Point2D.Float" + override val upperType = "LocationFloat" + + override val body = s""" + private static Float getFloatFromString(String s) { + if (s.equals("nan")) + return Float.NaN; + else if (s.equals("inf")) + return Float.POSITIVE_INFINITY; + else if (s.equals("-inf")) + return Float.NEGATIVE_INFINITY; + else + return Float.valueOf(s); + } + + $commonMethods + """ + + override val from = """ + float x = getFloatFromString(l.substring(1, l.indexOf(","))); + float y = getFloatFromString(l.substring(l.indexOf(",")+1, l.length()-1)); + return new java.awt.geom.Point2D.Float(x, y)""" +} + diff --git a/builder/src/main/scala/org/pgscala/builder/converters/scala/PGLocationConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/scala/PGLocationConverterBuilder.scala deleted file mode 100644 index 96f55dd..0000000 --- a/builder/src/main/scala/org/pgscala/builder/converters/scala/PGLocationConverterBuilder.scala +++ /dev/null @@ -1,16 +0,0 @@ -package org.pgscala -package builder -package converters - -object PGLocationConverterBuilder - extends PGConverterBuilder { - - override def imports = "import java.awt.geom._" - override val scalaUpperType = "Location" - - override val javaUpperType = "Location" - - val scalaClazz = "java.awt.geom.Point2D" - - val defaultValue = """new java.awt.geom.Point2D.Double()""" -} diff --git a/builder/src/main/scala/org/pgscala/builder/converters/scala/PGLocationDoubleConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/scala/PGLocationDoubleConverterBuilder.scala new file mode 100644 index 0000000..69eb14b --- /dev/null +++ b/builder/src/main/scala/org/pgscala/builder/converters/scala/PGLocationDoubleConverterBuilder.scala @@ -0,0 +1,17 @@ +package org.pgscala +package builder +package converters + +object PGLocationDoubleConverterBuilder + extends PGConverterBuilder { + + override def imports = "import java.awt.geom._" + override val scalaUpperType = "LocationDouble" + + override val javaUpperType = "LocationDouble" + + val scalaClazz = "java.awt.geom.Point2D.Double" + override val scalaType = "java.awt.geom.Point2D.Double" + + val defaultValue = """new java.awt.geom.Point2D.Double()""" +} diff --git a/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationConverter.java b/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationConverter.java index e672fdc..dac2fb8 100644 --- a/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationConverter.java +++ b/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationConverter.java @@ -20,9 +20,20 @@ else if (s.equals("-inf")) return Double.valueOf(s); } + private static String getStringFromDouble(Double s) { + if (s.isNaN()) + return "nan"; + else if (s == Double.POSITIVE_INFINITY) + return "inf"; + else if (s == Double.NEGATIVE_INFINITY) + return "-inf"; + else + return String.valueOf(s); + } + @ToString public static String locationToString(final java.awt.geom.Point2D l) { - if (null == l) return null; return "("+ l.getX()+","+l.getY()+")"; + if (null == l) return null; return "("+ getStringFromDouble(l.getX())+","+getStringFromDouble(l.getY())+")"; } @FromString diff --git a/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationDoubleConverter.java b/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationDoubleConverter.java new file mode 100644 index 0000000..80c15d4 --- /dev/null +++ b/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationDoubleConverter.java @@ -0,0 +1,56 @@ +package org.pgscala.converters; + +import org.joda.convert.*; + +/** Do not edit - generated in Builder / PGNullableLocationDoubleConverterBuilder.scala */ + +public enum PGNullableLocationDoubleConverter implements StringConverter { + INSTANCE; + + public static final String pgType = "point"; + + private static Double getDoubleFromString(String s) { + if (s.equals("nan")) + return Double.NaN; + else if (s.equals("inf")) + return Double.POSITIVE_INFINITY; + else if (s.equals("-inf")) + return Double.NEGATIVE_INFINITY; + else + return Double.valueOf(s); + } + + private static String getStringFromDouble(Double s) { + if (s.isNaN()) + return "nan"; + else if (s == Double.POSITIVE_INFINITY) + return "inf"; + else if (s == Double.NEGATIVE_INFINITY) + return "-inf"; + else + return String.valueOf(s); + } + + @ToString + public static String locationDoubleToString(final java.awt.geom.Point2D.Double l) { + if (null == l) return null; return "("+ getStringFromDouble(l.getX())+","+getStringFromDouble(l.getY())+")"; + } + + @FromString + public static java.awt.geom.Point2D.Double stringToLocationDouble(final String l) { + if (null == l) return null; + double x = getDoubleFromString(l.substring(1, l.indexOf(","))); + double y = getDoubleFromString(l.substring(l.indexOf(",")+1, l.length()-1)); + return new java.awt.geom.Point2D.Double(x, y); + } + +// ----------------------------------------------------------------------------- + + public String convertToString(final java.awt.geom.Point2D.Double l) { + return locationDoubleToString(l); + } + + public java.awt.geom.Point2D.Double convertFromString(final Class clazz, final String l) { + return stringToLocationDouble(l); + } +} diff --git a/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationFloatConverter.java b/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationFloatConverter.java new file mode 100644 index 0000000..d6d97b3 --- /dev/null +++ b/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationFloatConverter.java @@ -0,0 +1,56 @@ +package org.pgscala.converters; + +import org.joda.convert.*; + +/** Do not edit - generated in Builder / PGNullableLocationFloatConverterBuilder.scala */ + +public enum PGNullableLocationFloatConverter implements StringConverter { + INSTANCE; + + public static final String pgType = "point"; + + private static Float getFloatFromString(String s) { + if (s.equals("nan")) + return Float.NaN; + else if (s.equals("inf")) + return Float.POSITIVE_INFINITY; + else if (s.equals("-inf")) + return Float.NEGATIVE_INFINITY; + else + return Float.valueOf(s); + } + + private static String getStringFromDouble(Double s) { + if (s.isNaN()) + return "nan"; + else if (s == Double.POSITIVE_INFINITY) + return "inf"; + else if (s == Double.NEGATIVE_INFINITY) + return "-inf"; + else + return String.valueOf(s); + } + + @ToString + public static String locationFloatToString(final java.awt.geom.Point2D.Float l) { + if (null == l) return null; return "("+ getStringFromDouble(l.getX())+","+getStringFromDouble(l.getY())+")"; + } + + @FromString + public static java.awt.geom.Point2D.Float stringToLocationFloat(final String l) { + if (null == l) return null; + float x = getFloatFromString(l.substring(1, l.indexOf(","))); + float y = getFloatFromString(l.substring(l.indexOf(",")+1, l.length()-1)); + return new java.awt.geom.Point2D.Float(x, y); + } + +// ----------------------------------------------------------------------------- + + public String convertToString(final java.awt.geom.Point2D.Float l) { + return locationFloatToString(l); + } + + public java.awt.geom.Point2D.Float convertFromString(final Class clazz, final String l) { + return stringToLocationFloat(l); + } +} diff --git a/converters-java/src/test/scala/org/pgscala/converters/test/LocationTest.scala b/converters-java/src/test/scala/org/pgscala/converters/test/LocationTest.scala index 880e0c2..d22cbff 100644 --- a/converters-java/src/test/scala/org/pgscala/converters/test/LocationTest.scala +++ b/converters-java/src/test/scala/org/pgscala/converters/test/LocationTest.scala @@ -28,7 +28,7 @@ class LocationTest extends FeatureSpec with GivenWhenThen with Matchers { val p = new java.awt.geom.Point2D.Double(Double.NaN, Double.NaN); When("that value is converted to String") val res = PGNullableLocationConverter locationToString p - val expectedResult = s"(${Double.NaN},${Double.NaN})" + val expectedResult = "(nan,nan)" Then(s"It should return a String value $expectedResult") res should equal(expectedResult) } @@ -48,7 +48,7 @@ class LocationTest extends FeatureSpec with GivenWhenThen with Matchers { val p = new java.awt.geom.Point2D.Double(Double.PositiveInfinity, Double.NegativeInfinity); When("that value is converted to String") val res = PGNullableLocationConverter locationToString p - val expectedResult = s"(${Double.PositiveInfinity},${Double.NegativeInfinity})" + val expectedResult = "(inf,-inf)" Then(s"It should return a String value $expectedResult") res should equal(expectedResult) } diff --git a/converters-scala/src/generated/jasmin/org/pgscala/converters/PGNullableConverter.j b/converters-scala/src/generated/jasmin/org/pgscala/converters/PGNullableConverter.j index 3c792b3..b3a7b10 100644 --- a/converters-scala/src/generated/jasmin/org/pgscala/converters/PGNullableConverter.j +++ b/converters-scala/src/generated/jasmin/org/pgscala/converters/PGNullableConverter.j @@ -277,6 +277,38 @@ areturn .end method +.method public static fromPGString(Ljava/lang/String;)Ljava/awt/geom/Point2D/Double; + .limit locals 1 + .limit stack 2 + aload_0 + invokestatic org/pgscala/converters/PGNullableLocationDoubleConverter.stringToLocationDouble(Ljava/lang/String;)Ljava/awt/geom/Point2D/Double; + areturn +.end method + +.method public static toPGString(Ljava/awt/geom/Point2D/Double;)Ljava/lang/String; + .limit locals 1 + .limit stack 2 + aload_0 + invokestatic org/pgscala/converters/PGNullableLocationDoubleConverter.locationDoubleToString(Ljava/awt/geom/Point2D/Double;)Ljava/lang/String; + areturn +.end method + +.method public static fromPGString(Ljava/lang/String;)Ljava/awt/geom/Point2D/Float; + .limit locals 1 + .limit stack 2 + aload_0 + invokestatic org/pgscala/converters/PGNullableLocationFloatConverter.stringToLocationFloat(Ljava/lang/String;)Ljava/awt/geom/Point2D/Float; + areturn +.end method + +.method public static toPGString(Ljava/awt/geom/Point2D/Float;)Ljava/lang/String; + .limit locals 1 + .limit stack 2 + aload_0 + invokestatic org/pgscala/converters/PGNullableLocationFloatConverter.locationFloatToString(Ljava/awt/geom/Point2D/Float;)Ljava/lang/String; + areturn +.end method + .method public static fromPGString(Ljava/lang/String;)Ljava/awt/Point; .limit locals 1 .limit stack 2 diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala b/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala index 9e25450..1b60700 100644 --- a/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala +++ b/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala @@ -1,43 +1,43 @@ package org.pgscala.converters trait Implicits { - implicit val implicitPGStringConverter = PGStringConverter - implicit val implicitPGBooleanConverter = PGBooleanConverter - implicit val implicitPGShortConverter = PGShortConverter - implicit val implicitPGIntConverter = PGIntConverter - implicit val implicitPGLongConverter = PGLongConverter - implicit val implicitPGFloatConverter = PGFloatConverter - implicit val implicitPGDoubleConverter = PGDoubleConverter - implicit val implicitPGBigDecimalConverter = PGBigDecimalConverter - implicit val implicitPGBigIntConverter = PGBigIntConverter - implicit val implicitPGLocalDateConverter = PGLocalDateConverter - implicit val implicitPGDateTimeConverter = PGDateTimeConverter - implicit val implicitPGByteArrayConverter = PGByteArrayConverter - implicit val implicitPGBufferedImageConverter = PGBufferedImageConverter - implicit val implicitPGURLConverter = PGURLConverter - implicit val implicitPGUUIDConverter = PGUUIDConverter - implicit val implicitPGElemConverter = PGElemConverter - implicit val implicitPGMapConverter = PGMapConverter - implicit val implicitPGLocationConverter = PGLocationConverter - implicit val implicitPGPointConverter = PGPointConverter + implicit val implicitPGStringConverter = PGStringConverter + implicit val implicitPGBooleanConverter = PGBooleanConverter + implicit val implicitPGShortConverter = PGShortConverter + implicit val implicitPGIntConverter = PGIntConverter + implicit val implicitPGLongConverter = PGLongConverter + implicit val implicitPGFloatConverter = PGFloatConverter + implicit val implicitPGDoubleConverter = PGDoubleConverter + implicit val implicitPGBigDecimalConverter = PGBigDecimalConverter + implicit val implicitPGBigIntConverter = PGBigIntConverter + implicit val implicitPGLocalDateConverter = PGLocalDateConverter + implicit val implicitPGDateTimeConverter = PGDateTimeConverter + implicit val implicitPGByteArrayConverter = PGByteArrayConverter + implicit val implicitPGBufferedImageConverter = PGBufferedImageConverter + implicit val implicitPGURLConverter = PGURLConverter + implicit val implicitPGUUIDConverter = PGUUIDConverter + implicit val implicitPGElemConverter = PGElemConverter + implicit val implicitPGMapConverter = PGMapConverter + implicit val implicitPGLocationDoubleConverter = PGLocationDoubleConverter + implicit val implicitPGPointConverter = PGPointConverter - implicit val implicitPGOptionStringConverter = PGOptionStringConverter - implicit val implicitPGOptionBooleanConverter = PGOptionBooleanConverter - implicit val implicitPGOptionShortConverter = PGOptionShortConverter - implicit val implicitPGOptionIntConverter = PGOptionIntConverter - implicit val implicitPGOptionLongConverter = PGOptionLongConverter - implicit val implicitPGOptionFloatConverter = PGOptionFloatConverter - implicit val implicitPGOptionDoubleConverter = PGOptionDoubleConverter - implicit val implicitPGOptionBigDecimalConverter = PGOptionBigDecimalConverter - implicit val implicitPGOptionBigIntConverter = PGOptionBigIntConverter - implicit val implicitPGOptionLocalDateConverter = PGOptionLocalDateConverter - implicit val implicitPGOptionDateTimeConverter = PGOptionDateTimeConverter - implicit val implicitPGOptionByteArrayConverter = PGOptionByteArrayConverter - implicit val implicitPGOptionBufferedImageConverter = PGOptionBufferedImageConverter - implicit val implicitPGOptionURLConverter = PGOptionURLConverter - implicit val implicitPGOptionUUIDConverter = PGOptionUUIDConverter - implicit val implicitPGOptionElemConverter = PGOptionElemConverter - implicit val implicitPGOptionMapConverter = PGOptionMapConverter - implicit val implicitPGOptionLocationConverter = PGOptionLocationConverter - implicit val implicitPGOptionPointConverter = PGOptionPointConverter + implicit val implicitPGOptionStringConverter = PGOptionStringConverter + implicit val implicitPGOptionBooleanConverter = PGOptionBooleanConverter + implicit val implicitPGOptionShortConverter = PGOptionShortConverter + implicit val implicitPGOptionIntConverter = PGOptionIntConverter + implicit val implicitPGOptionLongConverter = PGOptionLongConverter + implicit val implicitPGOptionFloatConverter = PGOptionFloatConverter + implicit val implicitPGOptionDoubleConverter = PGOptionDoubleConverter + implicit val implicitPGOptionBigDecimalConverter = PGOptionBigDecimalConverter + implicit val implicitPGOptionBigIntConverter = PGOptionBigIntConverter + implicit val implicitPGOptionLocalDateConverter = PGOptionLocalDateConverter + implicit val implicitPGOptionDateTimeConverter = PGOptionDateTimeConverter + implicit val implicitPGOptionByteArrayConverter = PGOptionByteArrayConverter + implicit val implicitPGOptionBufferedImageConverter = PGOptionBufferedImageConverter + implicit val implicitPGOptionURLConverter = PGOptionURLConverter + implicit val implicitPGOptionUUIDConverter = PGOptionUUIDConverter + implicit val implicitPGOptionElemConverter = PGOptionElemConverter + implicit val implicitPGOptionMapConverter = PGOptionMapConverter + implicit val implicitPGOptionLocationDoubleConverter = PGOptionLocationDoubleConverter + implicit val implicitPGOptionPointConverter = PGOptionPointConverter } diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationConverter.scala index 911d20d..fcd740e 100644 --- a/converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationConverter.scala +++ b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationConverter.scala @@ -2,17 +2,17 @@ package org.pgscala.converters import java.awt.geom._ /** Do not edit - generated in Builder / PGLocationConverterBuilder.scala */ -object PGLocationConverter extends PGConverter[Point2D] { +object PGLocationConverter extends PGConverter[java.awt.geom.Point2D.Double] { val PGType = PGNullableLocationConverter.pgType - def toPGString(l: Point2D) = + def toPGString(l: java.awt.geom.Point2D.Double) = PGNullableLocationConverter.locationToString(l) - val defaultValue: Point2D = new java.awt.geom.Point2D.Double() + val defaultValue: Point2D.Double = new java.awt.geom.Point2D.Double() - def fromPGString(l: String) = + def fromPGString(l: String): java.awt.geom.Point2D.Double = if (l eq null) defaultValue else - PGNullableLocationConverter.stringToLocation(l) + PGNullableLocationConverter.stringToLocation(l).asInstanceOf[Point2D.Double] } diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationDoubleConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationDoubleConverter.scala new file mode 100644 index 0000000..2a4622d --- /dev/null +++ b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationDoubleConverter.scala @@ -0,0 +1,18 @@ +package org.pgscala.converters +import java.awt.geom._ +/** Do not edit - generated in Builder / PGLocationDoubleConverterBuilder.scala */ + +object PGLocationDoubleConverter extends PGConverter[java.awt.geom.Point2D.Double] { + val PGType = PGNullableLocationDoubleConverter.pgType + + def toPGString(ld: java.awt.geom.Point2D.Double) = + PGNullableLocationDoubleConverter.locationDoubleToString(ld) + + val defaultValue: java.awt.geom.Point2D.Double = new java.awt.geom.Point2D.Double() + + def fromPGString(ld: String) = + if (ld eq null) + defaultValue + else + PGNullableLocationDoubleConverter.stringToLocationDouble(ld) +} diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationConverter.scala index 1f7133c..1752e4e 100644 --- a/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationConverter.scala +++ b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationConverter.scala @@ -2,10 +2,10 @@ package org.pgscala.converters import java.awt.geom._ /** Do not edit - generated in Builder / PGLocationConverterBuilder.scala */ -object PGOptionLocationConverter extends PGConverter[Option[Point2D]] { +object PGOptionLocationConverter extends PGConverter[Option[java.awt.geom.Point2D.Double]] { val PGType = PGLocationConverter.PGType - def toPGString(ol: Option[Point2D]): String = + def toPGString(ol: Option[java.awt.geom.Point2D.Double]): String = ol match { case None => null @@ -13,7 +13,7 @@ object PGOptionLocationConverter extends PGConverter[Option[Point2D]] { PGLocationConverter.toPGString(l) } - def fromPGString(l: String): Option[Point2D] = + def fromPGString(l: String): Option[java.awt.geom.Point2D.Double] = l match { case null | "" => None diff --git a/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationDoubleConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationDoubleConverter.scala new file mode 100644 index 0000000..c9a0526 --- /dev/null +++ b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationDoubleConverter.scala @@ -0,0 +1,23 @@ +package org.pgscala.converters +import java.awt.geom._ +/** Do not edit - generated in Builder / PGLocationDoubleConverterBuilder.scala */ + +object PGOptionLocationDoubleConverter extends PGConverter[Option[java.awt.geom.Point2D.Double]] { + val PGType = PGLocationDoubleConverter.PGType + + def toPGString(old: Option[java.awt.geom.Point2D.Double]): String = + old match { + case None => + null + case Some(ld) => + PGLocationDoubleConverter.toPGString(ld) + } + + def fromPGString(ld: String): Option[java.awt.geom.Point2D.Double] = + ld match { + case null | "" => + None + case old => + Some(PGLocationDoubleConverter.fromPGString(old)) + } +} diff --git a/pgscala/src/test/scala/org/pgscala/test/PGDoubleFeatureSpec.scala b/pgscala/src/test/scala/org/pgscala/test/PGDoubleFeatureSpec.scala new file mode 100644 index 0000000..bee4d98 --- /dev/null +++ b/pgscala/src/test/scala/org/pgscala/test/PGDoubleFeatureSpec.scala @@ -0,0 +1,42 @@ +package org.pgscala +package test + +import org.junit.runner.RunWith +import org.scalatest.junit.JUnitRunner +import org.scalatest.FeatureSpec +import org.scalatest.GivenWhenThen +import org.scalatest.Matchers +import org.pgscala.converters.PGConverter + +@RunWith(classOf[JUnitRunner]) +class PGDoubleFeatureSpec extends FeatureSpec with GivenWhenThen with Matchers { + def using[T](f: PGScala => T) = + PGTestDb.sessionFactory.using(f) + + feature("PGDouble converter features"){ + + scenario("Double test 1 . 0"){ + val p = 0d + using(_.get[Double]("SELECT @1;", p)) should === (p) + using(_.get[Double]("SELECT $1;", p)) should === (p) + using(_.get[Double]("SELECT 0::double precision;")) should === (p) + } + + scenario("Double test 2 - NaN"){ + val p = Double.NaN + using(_.get[Double]("SELECT @1;", p)).isNaN() should be (true) + using(_.get[Double]("SELECT $1;", p)).isNaN() should be (true) + using(_.get[Double]("SELECT 'nan'::double precision;").isNaN()) should be (true) + } + + scenario("Double test 2 - Min Positive value"){ + val p = Double.MinPositiveValue + using(_.get[Double]("SELECT 4.9E-324::decimal;")) should === (p) + using(_.get[Double]("SELECT 4.9E-324::numeric;")) should === (p) + using(_.get[Double]("SELECT @1;", p)) should === (p) + using(_.get[Double]("SELECT $1;", p)) should === (p) + using(_.get[Double]("SELECT 4.9E-324::double precision;")) should === (p) + } + + } +} diff --git a/pgscala/src/test/scala/org/pgscala/test/PGLocationFeatureSpec.scala b/pgscala/src/test/scala/org/pgscala/test/PGLocationFeatureSpec.scala new file mode 100644 index 0000000..ee7ba3a --- /dev/null +++ b/pgscala/src/test/scala/org/pgscala/test/PGLocationFeatureSpec.scala @@ -0,0 +1,71 @@ +package org.pgscala +package test + +import org.junit.runner.RunWith +import org.scalatest.junit.JUnitRunner +import org.scalatest.FeatureSpec +import org.scalatest.GivenWhenThen +import org.scalatest.Matchers +import org.pgscala.converters.PGConverter + +@RunWith(classOf[JUnitRunner]) +class PGLocationFeatureSpec extends FeatureSpec with GivenWhenThen with Matchers { + def using[T](f: PGScala => T) = + PGTestDb.sessionFactory.using(f) + + feature("PGPoint converter features"){ + + scenario("Location(Double) test for (0,0)"){ + val p = new java.awt.geom.Point2D.Double(0d, 0d) + using(_.get[java.awt.geom.Point2D.Double]("SELECT @1;", p)) should === (p) + using(_.get[java.awt.geom.Point2D.Double]("SELECT $1;", p)) should === (p) + using(_.get[java.awt.geom.Point2D.Double]("SELECT point(0,0);")) should === (p) + } + + scenario("Location(Double) test for (-inf,inf)"){ + val p = new java.awt.geom.Point2D.Double(Double.PositiveInfinity, Double.NegativeInfinity) + using(_.get[java.awt.geom.Point2D.Double]("SELECT @1;", p)) should === (p) + using(_.get[java.awt.geom.Point2D.Double]("SELECT $1;", p)) should === (p) + using(_.get[java.awt.geom.Point2D.Double]("SELECT point(@1,@2);", Double.PositiveInfinity, Double.NegativeInfinity)) should === (p) + using(_.get[java.awt.geom.Point2D.Double]("SELECT point($1,$2);", Double.PositiveInfinity, Double.NegativeInfinity)) should === (p) + using(_.get[java.awt.geom.Point2D.Double]("SELECT point('inf','-inf');")) should === (p) + } + + scenario("Location(Double) test for (nan,nan)"){ + val p = new java.awt.geom.Point2D.Double(Double.NaN, Double.NaN) + using(_.get[java.awt.geom.Point2D.Double]("SELECT $1;", p)).getX().isNaN should be (true) + using(_.get[java.awt.geom.Point2D.Double]("SELECT point(@1,@2);", Double.NaN, Double.NaN)).getX().isNaN should be (true) + using(_.get[java.awt.geom.Point2D.Double]("SELECT point($1,$2);", Double.NaN, Double.NaN)).getX().isNaN should be (true) + using(_.get[java.awt.geom.Point2D.Double]("SELECT point('nan','nan');")).getX().isNaN should be (true) + } + + scenario("Location(Double) test for (min,max)"){ + val p = new java.awt.geom.Point2D.Double(Double.MinValue, Double.MaxValue) + val p2 = new java.awt.geom.Point2D.Double(Double.MinValue, Double.MinPositiveValue) + using(_.get[java.awt.geom.Point2D.Double]("SELECT @1;", p)) should === (p) + using(_.get[java.awt.geom.Point2D.Double]("SELECT $1;", p)) should === (p) + using(_.get[java.awt.geom.Point2D.Double]("SELECT point(@1,@2);", Double.MinValue, Double.MaxValue)) should === (p) + using(_.get[java.awt.geom.Point2D.Double]("SELECT point($1,$2);", Double.MinValue, Double.MaxValue)) should === (p) + + using(_.get[java.awt.geom.Point2D.Double]("SELECT @1;", p2)) should === (p2) + using(_.get[java.awt.geom.Point2D.Double]("SELECT $1;", p2)) should === (p2) + using(_.get[java.awt.geom.Point2D.Double]("SELECT point(@1,@2);", Double.MinPositiveValue, Double.MinPositiveValue)) should === (p2) + using(_.get[java.awt.geom.Point2D.Double]("SELECT point($1,$2);", Double.MinPositiveValue, Double.MinPositiveValue)) should === (p2) + } +// scenario("Point test for (MIN, MAX)"){ +// val p = new java.awt.Point(Integer.MAX_VALUE, Integer.MIN_VALUE) +// using(_.get[java.awt.Point]("SELECT @1;", p)) should === (p) +// using(_.get[java.awt.Point]("SELECT $1;", p)) should === (p) +// using(_.get[java.awt.Point]("SELECT point($1,$2);", Integer.MAX_VALUE, Integer.MIN_VALUE)) should === (p) +// } +// +// scenario("Point test for Random coordinates"){ +// val xCoord = scala.util.Random.nextInt() +// val yCoord = scala.util.Random.nextInt() +// val p = new java.awt.Point(xCoord, yCoord) +// using(_.get[java.awt.Point]("SELECT @1;", p)) should === (p) +// using(_.get[java.awt.Point]("SELECT $1;", p)) should === (p) +// using(_.get[java.awt.Point]("SELECT point($1, $2);", xCoord, yCoord)) should === (p) +// } + } +} diff --git a/pgscala/src/test/scala/org/pgscala/test/PGPointFeatureSpec.scala b/pgscala/src/test/scala/org/pgscala/test/PGPointFeatureSpec.scala new file mode 100644 index 0000000..00bc9cd --- /dev/null +++ b/pgscala/src/test/scala/org/pgscala/test/PGPointFeatureSpec.scala @@ -0,0 +1,40 @@ +package org.pgscala +package test + +import org.junit.runner.RunWith +import org.scalatest.junit.JUnitRunner +import org.scalatest.FeatureSpec +import org.scalatest.GivenWhenThen +import org.scalatest.Matchers + +@RunWith(classOf[JUnitRunner]) +class PGPointFeatureSpec extends FeatureSpec with GivenWhenThen with Matchers { + def using[T](f: PGScala => T) = + PGTestDb.sessionFactory.using(f) + + feature("PGPoint converter features"){ + + scenario("Point test For (0,0)"){ + val p = new java.awt.Point(0, 0) + using(_.get[java.awt.Point]("SELECT @1;", p)) should === (p) + using(_.get[java.awt.Point]("SELECT $1;", p)) should === (p) + using(_.get[java.awt.Point]("SELECT point(0,0);")) should === (p) + } + + scenario("Point test for (MIN, MAX)"){ + val p = new java.awt.Point(Integer.MAX_VALUE, Integer.MIN_VALUE) + using(_.get[java.awt.Point]("SELECT @1;", p)) should === (p) + using(_.get[java.awt.Point]("SELECT $1;", p)) should === (p) + using(_.get[java.awt.Point]("SELECT point($1,$2);", Integer.MAX_VALUE, Integer.MIN_VALUE)) should === (p) + } + + scenario("Point test for Random coordinates"){ + val xCoord = scala.util.Random.nextInt() + val yCoord = scala.util.Random.nextInt() + val p = new java.awt.Point(xCoord, yCoord) + using(_.get[java.awt.Point]("SELECT @1;", p)) should === (p) + using(_.get[java.awt.Point]("SELECT $1;", p)) should === (p) + using(_.get[java.awt.Point]("SELECT point($1, $2);", xCoord, yCoord)) should === (p) + } + } +} diff --git a/pgscala/src/test/scala/org/pgscala/test/PGScalaFeatureSpec.scala b/pgscala/src/test/scala/org/pgscala/test/PGScalaFeatureSpec.scala index 41e2746..1cb81c8 100644 --- a/pgscala/src/test/scala/org/pgscala/test/PGScalaFeatureSpec.scala +++ b/pgscala/src/test/scala/org/pgscala/test/PGScalaFeatureSpec.scala @@ -19,10 +19,5 @@ class PGScalaFeatureSpec extends FeatureSpec with GivenWhenThen with Matchers { using(_.get[BigDecimal]("SELECT @1;", bd)) should === (bd) using(_.get[BigDecimal]("SELECT $1;", bd)) should === (bd) } - - scenario("Point test"){ - val p = new java.awt.Point(0, 0) - using(_.get[java.awt.Point]("SELECT @1;", p)) should === (p) - } } }