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..e09a193 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 + + , PGLocationDoubleConverterBuilder + , PGPointConverterBuilder ) def buildScalaConverters() { 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..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,6 +147,10 @@ object PGNullableConverterBuilder extends PGConverterBuilderPaths { , PGNullableElemConverterBuilder , PGNullableMapConverterBuilder + , PGNullableLocationConverterBuilder + , PGNullableLocationDoubleConverterBuilder + , PGNullableLocationFloatConverterBuilder + , PGNullablePointConverterBuilder ) def buildJavaNullableConverters() { 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..28fa91d --- /dev/null +++ b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullableLocationConverterBuilder.scala @@ -0,0 +1,6 @@ +package org.pgscala +package builder +package converters + +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/java/PGNullablePointConverterBuilder.scala b/builder/src/main/scala/org/pgscala/builder/converters/java/PGNullablePointConverterBuilder.scala index 1dadf97..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 @@ -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.Point" - val to = "Long.toString(l)" + override val upperType = "Point" + override def javaType = clazz - val from = "Long.valueOf(l)" + val to = """return "("+ (int) p.getX()+","+ (int) p.getY()+")"""" + + val from = """ + 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;") } + 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/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/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-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..dac2fb8 --- /dev/null +++ b/converters-java/src/generated/java/org/pgscala/converters/PGNullableLocationConverter.java @@ -0,0 +1,56 @@ +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); + } + + 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 "("+ getStringFromDouble(l.getX())+","+getStringFromDouble(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/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/generated/java/org/pgscala/converters/PGNullablePointConverter.java b/converters-java/src/generated/java/org/pgscala/converters/PGNullablePointConverter.java new file mode 100644 index 0000000..0e39da9 --- /dev/null +++ b/converters-java/src/generated/java/org/pgscala/converters/PGNullablePointConverter.java @@ -0,0 +1,35 @@ +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.Point p) { + if (null == p) return null; return "("+ (int) p.getX()+","+ (int) p.getY()+")"; + } + + @FromString + public static java.awt.Point stringToPoint(final String p) { + if (null == p) return null; + 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.Point p) { + return pointToString(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..d22cbff --- /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 = "(nan,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 = "(inf,-inf)" + 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 new file mode 100644 index 0000000..8b254c0 --- /dev/null +++ b/converters-java/src/test/scala/org/pgscala/converters/test/PointTest.scala @@ -0,0 +1,89 @@ +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("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"(${Int.MaxValue},${Int.MinValue})" + Then(s"It should return a String value $expectedResult") + res should equal(expectedResult) + } + + + scenario("Integer Point to String Nr. 2") { + Given("a starting Point(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 = "(0,0)" + Then(s"It should return a String value $expectedResult") + res should equal(expectedResult) + } + + 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 + 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("String to Point Nr. 1") { + 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.Point(2147483647, -2147483648); + 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 = PGNullablePointConverter stringToPoint(given) + When(s"that value is converted to String $res") + val expectedResult = null; + Then(s"It should return a Point value $expectedResult") + res should be(null) + } + + scenario("String to Point Nr. 3") { + 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.Point(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 = PGNullablePointConverter stringToPoint(given) + When(s"that value is converted to String $res") + 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 e79dd5e..b3a7b10 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,67 @@ 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/PGNullableLocationConverter.stringToLocation(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/PGNullableLocationConverter.locationToString(Ljava/awt/geom/Point2D;)Ljava/lang/String; + 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 + 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/Implicits.scala b/converters-scala/src/generated/scala/org/pgscala/converters/Implicits.scala index d56ba14..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,35 +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 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 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 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 + implicit val implicitPGOptionLocationDoubleConverter = PGOptionLocationDoubleConverter + 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 new file mode 100644 index 0000000..d29a6b6 --- /dev/null +++ b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGBufferedImageConverter.scala @@ -0,0 +1,18 @@ +package org.pgscala.converters +import java.awt.image.BufferedImage +/** 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/PGLocationConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/core/PGLocationConverter.scala new file mode 100644 index 0000000..fcd740e --- /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[java.awt.geom.Point2D.Double] { + val PGType = PGNullableLocationConverter.pgType + + def toPGString(l: java.awt.geom.Point2D.Double) = + PGNullableLocationConverter.locationToString(l) + + val defaultValue: Point2D.Double = new java.awt.geom.Point2D.Double() + + def fromPGString(l: String): java.awt.geom.Point2D.Double = + if (l eq null) + defaultValue + else + 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/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/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..468b818 --- /dev/null +++ b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionBufferedImageConverter.scala @@ -0,0 +1,23 @@ +package org.pgscala.converters +import java.awt.image.BufferedImage +/** 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/PGOptionLocationConverter.scala b/converters-scala/src/generated/scala/org/pgscala/converters/option/PGOptionLocationConverter.scala new file mode 100644 index 0000000..1752e4e --- /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[java.awt.geom.Point2D.Double]] { + val PGType = PGLocationConverter.PGType + + def toPGString(ol: Option[java.awt.geom.Point2D.Double]): String = + ol match { + case None => + null + case Some(l) => + PGLocationConverter.toPGString(l) + } + + def fromPGString(l: String): Option[java.awt.geom.Point2D.Double] = + l match { + case null | "" => + None + case ol => + Some(PGLocationConverter.fromPGString(ol)) + } +} 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/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/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)) + } +} 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) + } + } +}