[Practicalxml-commits] SF.net SVN: practicalxml:[105] branches/dev-1.1/src
Brought to you by:
kdgregory
Menu
▾
▴
[Practicalxml-commits] SF.net SVN: practicalxml:[105] branches/dev-1.1/src
|
From: Auto-Generated S. C. M. <pra...@li...> - 2009-08-14 20:05:46
|
Revision: 105
http://practicalxml.svn.sourceforge.net/practicalxml/?rev=105&view=rev
Author: kdgregory
Date: 2009-08-14 20:05:39 +0000 (Fri, 14 Aug 2009)
Log Message:
-----------
rename PrimitiveConversionHelper to ConversionHelper
Modified Paths:
--------------
branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/bean2xml/Bean2XmlDriver.java
branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/xml2bean/Xml2BeanHandler.java
Added Paths:
-----------
branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/ConversionHelper.java
branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestConversionHelper.java
Removed Paths:
-------------
branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/PrimitiveConversionHelper.java
branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestPrimitiveConversionHelper.java
Copied: branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/ConversionHelper.java (from rev 99, branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/PrimitiveConversionHelper.java)
===================================================================
--- branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/ConversionHelper.java (rev 0)
+++ branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/ConversionHelper.java 2009-08-14 20:05:39 UTC (rev 105)
@@ -0,0 +1,446 @@
+// Copyright 2008-2009 severally by the contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package net.sf.practicalxml.converter;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+import net.sf.practicalxml.XmlUtil;
+
+
+/**
+ * Responsible for converting "primitive" types -- those with unambiguous
+ * string representations -- to/from such a representation.
+ */
+public class ConversionHelper
+{
+ // this is not static because the helpers are inner classes
+ private Map<Class<?>,ConversionHandler<?>> _helpers
+ = new HashMap<Class<?>,ConversionHandler<?>>();
+ {
+ _helpers.put(String.class, new StringConversionHandler());
+ _helpers.put(Character.class, new CharacterConversionHandler());
+ _helpers.put(Boolean.class, new BooleanConversionHandler());
+ _helpers.put(Byte.class, new ByteConversionHandler());
+ _helpers.put(Short.class, new ShortConversionHandler());
+ _helpers.put(Integer.class, new IntegerConversionHandler());
+ _helpers.put(Long.class, new LongConversionHandler());
+ _helpers.put(Float.class, new FloatConversionHandler());
+ _helpers.put(Double.class, new DoubleConversionHandler());
+ _helpers.put(BigInteger.class, new BigIntegerConversionHandler());
+ _helpers.put(BigDecimal.class, new BigDecimalConversionHandler());
+ _helpers.put(Date.class, new DateConversionHandler());
+ }
+
+ private boolean _useXsdFormatting;
+
+
+ /**
+ * Default constructor, which uses Java formatting.
+ */
+ public ConversionHelper()
+ {
+ // nothing to see here
+ }
+
+
+ /**
+ * Constructor that allows selection of Java or XSD formatting.
+ */
+ public ConversionHelper(boolean useXsdFormatting)
+ {
+ _useXsdFormatting = useXsdFormatting;
+ }
+
+
+//----------------------------------------------------------------------------
+// Public Methods
+//----------------------------------------------------------------------------
+
+ /**
+ * Returns the XSD type name to use for stringified objects of the
+ * specified class, <code>null</code> if this converter can't convert
+ * instances of the class.
+ */
+ public String getXsdType(Class<?> klass)
+ {
+ ConversionHandler<?> helper = _helpers.get(klass);
+ return (helper == null) ? null : helper.getXsiType();
+ }
+
+
+ /**
+ * Converts the passed object into its string representation, according
+ * to the options currently in effect. Passing <code>null</code> will
+ * return <code>null</code>. Throws {@link ConversionException} if
+ * unable to convert the passed object.
+ */
+ public String stringify(Object obj)
+ {
+ if (obj == null)
+ return null;
+
+ try
+ {
+ return getHelper(obj.getClass()).stringify(obj);
+ }
+ catch (Exception ee)
+ {
+ if (ee instanceof ConversionException)
+ throw (ConversionException)ee;
+ throw new ConversionException("unable to convert: " + obj, ee);
+ }
+ }
+
+
+ /**
+ * Parses the passed string into an object of the desired class. Passing
+ * <code>null</code> will return <code>null</code>, passing an empty
+ * string will typically throw a {@link ConversionException}.
+ */
+ public Object parse(String str, Class<?> klass)
+ {
+ if (str == null)
+ return null;
+
+ try
+ {
+ return getHelper(klass).parse(str);
+ }
+ catch (Exception ee)
+ {
+ if (ee instanceof ConversionException)
+ throw (ConversionException)ee;
+ throw new ConversionException("unable to parse: " + str, ee);
+ }
+ }
+
+
+//----------------------------------------------------------------------------
+// Internals
+//----------------------------------------------------------------------------
+
+ /**
+ * Returns the appropriate conversion helper or throws.
+ */
+ @SuppressWarnings(value="unchecked")
+ private ConversionHandler getHelper(Class<?> klass)
+ {
+ ConversionHandler<?> helper = _helpers.get(klass);
+ if (helper == null)
+ throw new ConversionException("unable to get helper: " + klass.getName());
+ return helper;
+ }
+
+
+ /**
+ * Each primitive class has its own conversion handler that is responsible
+ * for converting to/from a string representation. Handlers are guaranteed
+ * to receive non-null objects/strings.
+ * <p>
+ * This interface is parameterized so that the compiler will generate
+ * bridge methods for implementation classes. Elsewhere, we don't care
+ * about parameterization, so wildcard or drop it (see {@link #getHelper}).
+ * <p>
+ * Implementation classes are expected to be inner classes, so that they
+ * have access to configuration information (such as formatting rules).
+ * <p>
+ * Implementation classes are permitted to throw any exception; caller is
+ * expected to catch them and translate to a {@link ConversionException}.
+ */
+ private static interface ConversionHandler<T>
+ {
+ public String getXsiType();
+ public String stringify(T obj) throws Exception;
+ public T parse(String str) throws Exception;
+ }
+
+
+ private class StringConversionHandler
+ implements ConversionHandler<String>
+ {
+ public String getXsiType()
+ {
+ return "xsd:string";
+ }
+
+ public String stringify(String obj)
+ {
+ return String.valueOf(obj);
+ }
+
+ public String parse(String str)
+ {
+ return str;
+ }
+ }
+
+
+ private class CharacterConversionHandler
+ implements ConversionHandler<Character>
+ {
+ private final Character NUL = Character.valueOf('\0');
+
+ public String getXsiType()
+ {
+ return "xsd:string";
+ }
+
+ public String stringify(Character obj)
+ {
+ if (obj.equals(NUL))
+ return "";
+ return obj.toString();
+ }
+
+ public Character parse(String str)
+ {
+ if (str.length() == 0)
+ return NUL;
+ if (str.length() > 1)
+ throw new ConversionException(
+ "attempted to convert multi-character string: \"" + str + "\"");
+ return Character.valueOf(str.charAt(0));
+ }
+ }
+
+
+ private class BooleanConversionHandler
+ implements ConversionHandler<Boolean>
+ {
+ public String getXsiType()
+ {
+ return "xsd:boolean";
+ }
+
+ public String stringify(Boolean obj)
+ {
+ return _useXsdFormatting
+ ? XmlUtil.formatXsdBoolean(obj.booleanValue())
+ : obj.toString();
+ }
+
+ public Boolean parse(String str)
+ {
+ return _useXsdFormatting
+ ? XmlUtil.parseXsdBoolean(str)
+ : Boolean.parseBoolean(str);
+ }
+ }
+
+
+ private class ByteConversionHandler
+ implements ConversionHandler<Byte>
+ {
+ public String getXsiType()
+ {
+ return "xsd:byte";
+ }
+
+ public String stringify(Byte obj)
+ {
+ return obj.toString();
+ }
+
+ public Byte parse(String str)
+ {
+ return Byte.valueOf(str.trim());
+ }
+ }
+
+
+ private class ShortConversionHandler
+ implements ConversionHandler<Short>
+ {
+ public String getXsiType()
+ {
+ return "xsd:short";
+ }
+
+ public String stringify(Short obj)
+ {
+ return obj.toString();
+ }
+
+ public Short parse(String str)
+ {
+ return Short.valueOf(str.trim());
+ }
+ }
+
+
+ private class IntegerConversionHandler
+ implements ConversionHandler<Integer>
+ {
+ public String getXsiType()
+ {
+ return "xsd:int";
+ }
+
+ public String stringify(Integer obj)
+ {
+ return obj.toString();
+ }
+
+ public Integer parse(String str)
+ {
+ return Integer.valueOf(str.trim());
+ }
+ }
+
+
+ private class LongConversionHandler
+ implements ConversionHandler<Long>
+ {
+ public String getXsiType()
+ {
+ return "xsd:long";
+ }
+
+ public String stringify(Long obj)
+ {
+ return obj.toString();
+ }
+
+ public Long parse(String str)
+ {
+ return Long.valueOf(str.trim());
+ }
+ }
+
+
+ private class FloatConversionHandler
+ implements ConversionHandler<Float>
+ {
+ public String getXsiType()
+ {
+ return "xsd:decimal";
+ }
+
+ public String stringify(Float obj)
+ {
+ return _useXsdFormatting
+ ? XmlUtil.formatXsdDecimal(obj)
+ : obj.toString();
+ }
+
+ public Float parse(String str)
+ {
+ return Float.valueOf(str.trim());
+ }
+ }
+
+
+ private class DoubleConversionHandler
+ implements ConversionHandler<Double>
+ {
+ public String getXsiType()
+ {
+ return "xsd:decimal";
+ }
+
+ public String stringify(Double obj)
+ {
+ return _useXsdFormatting
+ ? XmlUtil.formatXsdDecimal(obj)
+ : obj.toString();
+ }
+
+ public Double parse(String str)
+ {
+ return Double.valueOf(str.trim());
+ }
+ }
+
+
+ private class BigIntegerConversionHandler
+ implements ConversionHandler<BigInteger>
+ {
+ public String getXsiType()
+ {
+ return "xsd:decimal";
+ }
+
+ public String stringify(BigInteger obj)
+ {
+ return obj.toString();
+ }
+
+ public BigInteger parse(String str)
+ {
+ return new BigInteger(str.trim());
+ }
+ }
+
+
+ private class BigDecimalConversionHandler
+ implements ConversionHandler<BigDecimal>
+ {
+ public String getXsiType()
+ {
+ return "xsd:decimal";
+ }
+
+ public String stringify(BigDecimal obj)
+ {
+ return obj.toString();
+ }
+
+ public BigDecimal parse(String str)
+ {
+ return new BigDecimal(str.trim());
+ }
+ }
+
+
+ private class DateConversionHandler
+ implements ConversionHandler<Date>
+ {
+ // format as specified by Date.toString() JavaDoc
+ private DateFormat _defaultFormat = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy");
+
+ public String getXsiType()
+ {
+ return "xsd:dateTime";
+ }
+
+ public String stringify(Date obj)
+ {
+ return _useXsdFormatting
+ ? XmlUtil.formatXsdDatetime(obj)
+ : obj.toString();
+ }
+
+ public Date parse(String str)
+ throws ParseException
+ {
+ if (_useXsdFormatting)
+ return XmlUtil.parseXsdDatetime(str);
+ else
+ {
+ synchronized (_defaultFormat)
+ {
+ return _defaultFormat.parse(str);
+ }
+ }
+ }
+ }
+}
Deleted: branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/PrimitiveConversionHelper.java
===================================================================
--- branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/PrimitiveConversionHelper.java 2009-08-14 19:00:11 UTC (rev 104)
+++ branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/PrimitiveConversionHelper.java 2009-08-14 20:05:39 UTC (rev 105)
@@ -1,446 +0,0 @@
-// Copyright 2008-2009 severally by the contributors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package net.sf.practicalxml.converter;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.text.DateFormat;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
-
-import net.sf.practicalxml.XmlUtil;
-
-
-/**
- * Responsible for converting "primitive" types -- those with unambiguous
- * string representations -- to/from such a representation.
- */
-public class PrimitiveConversionHelper
-{
- // this is not static because the helpers are inner classes
- private Map<Class<?>,ConversionHandler<?>> _helpers
- = new HashMap<Class<?>,ConversionHandler<?>>();
- {
- _helpers.put(String.class, new StringConversionHandler());
- _helpers.put(Character.class, new CharacterConversionHandler());
- _helpers.put(Boolean.class, new BooleanConversionHandler());
- _helpers.put(Byte.class, new ByteConversionHandler());
- _helpers.put(Short.class, new ShortConversionHandler());
- _helpers.put(Integer.class, new IntegerConversionHandler());
- _helpers.put(Long.class, new LongConversionHandler());
- _helpers.put(Float.class, new FloatConversionHandler());
- _helpers.put(Double.class, new DoubleConversionHandler());
- _helpers.put(BigInteger.class, new BigIntegerConversionHandler());
- _helpers.put(BigDecimal.class, new BigDecimalConversionHandler());
- _helpers.put(Date.class, new DateConversionHandler());
- }
-
- private boolean _useXsdFormatting;
-
-
- /**
- * Default constructor, which uses Java formatting.
- */
- public PrimitiveConversionHelper()
- {
- // nothing to see here
- }
-
-
- /**
- * Constructor that allows selection of Java or XSD formatting.
- */
- public PrimitiveConversionHelper(boolean useXsdFormatting)
- {
- _useXsdFormatting = useXsdFormatting;
- }
-
-
-//----------------------------------------------------------------------------
-// Public Methods
-//----------------------------------------------------------------------------
-
- /**
- * Returns the XSD type name to use for stringified objects of the
- * specified class, <code>null</code> if this converter can't convert
- * instances of the class.
- */
- public String getXsdType(Class<?> klass)
- {
- ConversionHandler<?> helper = _helpers.get(klass);
- return (helper == null) ? null : helper.getXsiType();
- }
-
-
- /**
- * Converts the passed object into its string representation, according
- * to the options currently in effect. Passing <code>null</code> will
- * return <code>null</code>. Throws {@link ConversionException} if
- * unable to convert the passed object.
- */
- public String stringify(Object obj)
- {
- if (obj == null)
- return null;
-
- try
- {
- return getHelper(obj.getClass()).stringify(obj);
- }
- catch (Exception ee)
- {
- if (ee instanceof ConversionException)
- throw (ConversionException)ee;
- throw new ConversionException("unable to convert: " + obj, ee);
- }
- }
-
-
- /**
- * Parses the passed string into an object of the desired class. Passing
- * <code>null</code> will return <code>null</code>, passing an empty
- * string will typically throw a {@link ConversionException}.
- */
- public Object parse(String str, Class<?> klass)
- {
- if (str == null)
- return null;
-
- try
- {
- return getHelper(klass).parse(str);
- }
- catch (Exception ee)
- {
- if (ee instanceof ConversionException)
- throw (ConversionException)ee;
- throw new ConversionException("unable to parse: " + str, ee);
- }
- }
-
-
-//----------------------------------------------------------------------------
-// Internals
-//----------------------------------------------------------------------------
-
- /**
- * Returns the appropriate conversion helper or throws.
- */
- @SuppressWarnings(value="unchecked")
- private ConversionHandler getHelper(Class<?> klass)
- {
- ConversionHandler<?> helper = _helpers.get(klass);
- if (helper == null)
- throw new ConversionException("unable to get helper: " + klass.getName());
- return helper;
- }
-
-
- /**
- * Each primitive class has its own conversion handler that is responsible
- * for converting to/from a string representation. Handlers are guaranteed
- * to receive non-null objects/strings.
- * <p>
- * This interface is parameterized so that the compiler will generate
- * bridge methods for implementation classes. Elsewhere, we don't care
- * about parameterization, so wildcard or drop it (see {@link #getHelper}).
- * <p>
- * Implementation classes are expected to be inner classes, so that they
- * have access to configuration information (such as formatting rules).
- * <p>
- * Implementation classes are permitted to throw any exception; caller is
- * expected to catch them and translate to a {@link ConversionException}.
- */
- private static interface ConversionHandler<T>
- {
- public String getXsiType();
- public String stringify(T obj) throws Exception;
- public T parse(String str) throws Exception;
- }
-
-
- private class StringConversionHandler
- implements ConversionHandler<String>
- {
- public String getXsiType()
- {
- return "xsd:string";
- }
-
- public String stringify(String obj)
- {
- return String.valueOf(obj);
- }
-
- public String parse(String str)
- {
- return str;
- }
- }
-
-
- private class CharacterConversionHandler
- implements ConversionHandler<Character>
- {
- private final Character NUL = Character.valueOf('\0');
-
- public String getXsiType()
- {
- return "xsd:string";
- }
-
- public String stringify(Character obj)
- {
- if (obj.equals(NUL))
- return "";
- return obj.toString();
- }
-
- public Character parse(String str)
- {
- if (str.length() == 0)
- return NUL;
- if (str.length() > 1)
- throw new ConversionException(
- "attempted to convert multi-character string: \"" + str + "\"");
- return Character.valueOf(str.charAt(0));
- }
- }
-
-
- private class BooleanConversionHandler
- implements ConversionHandler<Boolean>
- {
- public String getXsiType()
- {
- return "xsd:boolean";
- }
-
- public String stringify(Boolean obj)
- {
- return _useXsdFormatting
- ? XmlUtil.formatXsdBoolean(obj.booleanValue())
- : obj.toString();
- }
-
- public Boolean parse(String str)
- {
- return _useXsdFormatting
- ? XmlUtil.parseXsdBoolean(str)
- : Boolean.parseBoolean(str);
- }
- }
-
-
- private class ByteConversionHandler
- implements ConversionHandler<Byte>
- {
- public String getXsiType()
- {
- return "xsd:byte";
- }
-
- public String stringify(Byte obj)
- {
- return obj.toString();
- }
-
- public Byte parse(String str)
- {
- return Byte.valueOf(str.trim());
- }
- }
-
-
- private class ShortConversionHandler
- implements ConversionHandler<Short>
- {
- public String getXsiType()
- {
- return "xsd:short";
- }
-
- public String stringify(Short obj)
- {
- return obj.toString();
- }
-
- public Short parse(String str)
- {
- return Short.valueOf(str.trim());
- }
- }
-
-
- private class IntegerConversionHandler
- implements ConversionHandler<Integer>
- {
- public String getXsiType()
- {
- return "xsd:int";
- }
-
- public String stringify(Integer obj)
- {
- return obj.toString();
- }
-
- public Integer parse(String str)
- {
- return Integer.valueOf(str.trim());
- }
- }
-
-
- private class LongConversionHandler
- implements ConversionHandler<Long>
- {
- public String getXsiType()
- {
- return "xsd:long";
- }
-
- public String stringify(Long obj)
- {
- return obj.toString();
- }
-
- public Long parse(String str)
- {
- return Long.valueOf(str.trim());
- }
- }
-
-
- private class FloatConversionHandler
- implements ConversionHandler<Float>
- {
- public String getXsiType()
- {
- return "xsd:decimal";
- }
-
- public String stringify(Float obj)
- {
- return _useXsdFormatting
- ? XmlUtil.formatXsdDecimal(obj)
- : obj.toString();
- }
-
- public Float parse(String str)
- {
- return Float.valueOf(str.trim());
- }
- }
-
-
- private class DoubleConversionHandler
- implements ConversionHandler<Double>
- {
- public String getXsiType()
- {
- return "xsd:decimal";
- }
-
- public String stringify(Double obj)
- {
- return _useXsdFormatting
- ? XmlUtil.formatXsdDecimal(obj)
- : obj.toString();
- }
-
- public Double parse(String str)
- {
- return Double.valueOf(str.trim());
- }
- }
-
-
- private class BigIntegerConversionHandler
- implements ConversionHandler<BigInteger>
- {
- public String getXsiType()
- {
- return "xsd:decimal";
- }
-
- public String stringify(BigInteger obj)
- {
- return obj.toString();
- }
-
- public BigInteger parse(String str)
- {
- return new BigInteger(str.trim());
- }
- }
-
-
- private class BigDecimalConversionHandler
- implements ConversionHandler<BigDecimal>
- {
- public String getXsiType()
- {
- return "xsd:decimal";
- }
-
- public String stringify(BigDecimal obj)
- {
- return obj.toString();
- }
-
- public BigDecimal parse(String str)
- {
- return new BigDecimal(str.trim());
- }
- }
-
-
- private class DateConversionHandler
- implements ConversionHandler<Date>
- {
- // format as specified by Date.toString() JavaDoc
- private DateFormat _defaultFormat = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy");
-
- public String getXsiType()
- {
- return "xsd:dateTime";
- }
-
- public String stringify(Date obj)
- {
- return _useXsdFormatting
- ? XmlUtil.formatXsdDatetime(obj)
- : obj.toString();
- }
-
- public Date parse(String str)
- throws ParseException
- {
- if (_useXsdFormatting)
- return XmlUtil.parseXsdDatetime(str);
- else
- {
- synchronized (_defaultFormat)
- {
- return _defaultFormat.parse(str);
- }
- }
- }
- }
-}
Modified: branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/bean2xml/Bean2XmlDriver.java
===================================================================
--- branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/bean2xml/Bean2XmlDriver.java 2009-08-14 19:00:11 UTC (rev 104)
+++ branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/bean2xml/Bean2XmlDriver.java 2009-08-14 20:05:39 UTC (rev 105)
@@ -28,7 +28,7 @@
import net.sf.practicalxml.DomUtil;
import net.sf.practicalxml.converter.ConversionException;
-import net.sf.practicalxml.converter.PrimitiveConversionHelper;
+import net.sf.practicalxml.converter.ConversionHelper;
import net.sf.practicalxml.converter.bean2xml.Bean2XmlAppenders.*;
@@ -42,13 +42,13 @@
public class Bean2XmlDriver
{
private EnumSet<Bean2XmlOptions> _options = EnumSet.noneOf(Bean2XmlOptions.class);
- private PrimitiveConversionHelper _primitiveHelper;
+ private ConversionHelper _primitiveHelper;
public Bean2XmlDriver(Bean2XmlOptions... options)
{
for (Bean2XmlOptions option : options)
_options.add(option);
- _primitiveHelper = new PrimitiveConversionHelper(shouldUseXsdFormatting());
+ _primitiveHelper = new ConversionHelper(shouldUseXsdFormatting());
}
Modified: branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/xml2bean/Xml2BeanHandler.java
===================================================================
--- branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/xml2bean/Xml2BeanHandler.java 2009-08-14 19:00:11 UTC (rev 104)
+++ branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/xml2bean/Xml2BeanHandler.java 2009-08-14 20:05:39 UTC (rev 105)
@@ -18,7 +18,7 @@
import net.sf.practicalxml.XmlException;
import net.sf.practicalxml.XmlUtil;
import net.sf.practicalxml.converter.ConversionException;
-import net.sf.practicalxml.converter.PrimitiveConversionHelper;
+import net.sf.practicalxml.converter.ConversionHelper;
import net.sf.practicalxml.internal.StringUtils;
import java.util.Arrays;
@@ -42,7 +42,7 @@
public class Xml2BeanHandler
{
private EnumSet<Xml2BeanOptions> _options;
- private PrimitiveConversionHelper _primitiveHelper;
+ private ConversionHelper _primitiveHelper;
/**
@@ -54,7 +54,7 @@
for (Xml2BeanOptions option : options)
_options.add(option);
- _primitiveHelper = new PrimitiveConversionHelper(true);
+ _primitiveHelper = new ConversionHelper(true);
}
Copied: branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestConversionHelper.java (from rev 99, branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestPrimitiveConversionHelper.java)
===================================================================
--- branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestConversionHelper.java (rev 0)
+++ branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestConversionHelper.java 2009-08-14 20:05:39 UTC (rev 105)
@@ -0,0 +1,529 @@
+// Copyright 2008-2009 severally by the contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package net.sf.practicalxml.converter;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Date;
+
+
+public class TestConversionHelper
+extends AbstractBeanConverterTestCase
+{
+ public TestConversionHelper(String name)
+ {
+ super(name);
+ }
+
+
+//----------------------------------------------------------------------------
+// Support Code
+//----------------------------------------------------------------------------
+
+ private void assertFailsConversionToObject(
+ String message,
+ ConversionHelper helper,
+ String str,
+ Class<?> klass)
+ {
+ try
+ {
+ helper.parse(str, klass);
+ fail(message);
+ }
+ catch (ConversionException ee)
+ {
+ // success!
+ }
+ }
+
+
+//----------------------------------------------------------------------------
+// Test Cases
+//----------------------------------------------------------------------------
+
+ public void testUnknownClass() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ assertNull(helper.getXsdType(Class.class));
+ }
+
+
+ public void testConvertNull() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ assertNull(helper.stringify(null));
+ assertNull(helper.parse(null, Object.class));
+ }
+
+
+ public void testConvertString() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ assertEquals("xsd:string", helper.getXsdType(String.class));
+
+ assertEquals("foo", helper.stringify("foo"));
+ assertEquals("foo", helper.parse("foo", String.class));
+
+ assertEquals("", helper.stringify(""));
+ assertEquals("", helper.parse("", String.class));
+ }
+
+
+ public void testConvertCharacter() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ assertEquals("xsd:string", helper.getXsdType(Character.class));
+
+ Character simple = Character.valueOf('A');
+ assertEquals("A", helper.stringify(simple));
+ assertEquals(simple, helper.parse("A", Character.class));
+
+ Character nul = Character.valueOf('\0');
+ assertEquals("", helper.stringify(nul));
+ assertEquals(nul, helper.parse("", Character.class));
+
+ assertFailsConversionToObject(
+ "converted multi-character string",
+ helper, "ix", Character.class);
+ }
+
+
+ public void testConvertBooleanDefault() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ // default boolean conversion is compatible with XSD type def
+ assertEquals("xsd:boolean", helper.getXsdType(Boolean.class));
+
+ String sTrue = Boolean.TRUE.toString();
+ assertEquals(sTrue, helper.stringify(Boolean.TRUE));
+ assertEquals(Boolean.TRUE, helper.parse(sTrue, Boolean.class));
+
+ String sFalse = Boolean.FALSE.toString();
+ assertEquals(sFalse, helper.stringify(Boolean.FALSE));
+ assertEquals(Boolean.FALSE, helper.parse(sFalse, Boolean.class));
+
+ assertEquals(Boolean.FALSE, helper.parse("ix", Boolean.class));
+ assertEquals(Boolean.FALSE, helper.parse("", Boolean.class));
+ }
+
+
+ public void testConvertBooleanXsd() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper(true);
+
+ assertEquals("xsd:boolean", helper.getXsdType(Boolean.class));
+
+ assertEquals("true", helper.stringify(Boolean.TRUE));
+ assertEquals(Boolean.TRUE, helper.parse("true", Boolean.class));
+ assertEquals(Boolean.TRUE, helper.parse("1", Boolean.class));
+
+ assertEquals("false", helper.stringify(Boolean.FALSE));
+ assertEquals(Boolean.FALSE, helper.parse("false", Boolean.class));
+ assertEquals(Boolean.FALSE, helper.parse("0", Boolean.class));
+
+ assertFailsConversionToObject(
+ "converted multi-character string",
+ helper, "ix", Boolean.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", Boolean.class);
+ }
+
+
+ public void testConvertByte() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ assertEquals("xsd:byte", helper.getXsdType(Byte.class));
+
+ String str1 = "123";
+ Byte val1 = Byte.valueOf((byte)123);
+ assertEquals(str1, helper.stringify(val1));
+ assertEquals(val1, helper.parse(str1, Byte.class));
+
+ String str2 = "-123";
+ Byte val2 = Byte.valueOf((byte)-123);
+ assertEquals(str2, helper.stringify(val2));
+ assertEquals(val2, helper.parse(str2, Byte.class));
+
+ String str3 = " -123 ";
+ Byte val3 = Byte.valueOf((byte)-123);
+ assertEquals(val3, helper.parse(str3, Byte.class));
+
+ assertFailsConversionToObject(
+ "converted too-large value",
+ helper, "1234567", Byte.class);
+
+ assertFailsConversionToObject(
+ "converted non-integer value",
+ helper, "1.23", Byte.class);
+
+ assertFailsConversionToObject(
+ "converted non-numeric value",
+ helper, "ix", Byte.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", Byte.class);
+ }
+
+
+ public void testConvertShort() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ assertEquals("xsd:short", helper.getXsdType(Short.class));
+
+ String str1 = "12345";
+ Short val1 = Short.valueOf((short)12345);
+ assertEquals(str1, helper.stringify(val1));
+ assertEquals(val1, helper.parse(str1, Short.class));
+
+ String str2 = "-12345";
+ Short val2 = Short.valueOf((short)-12345);
+ assertEquals(str2, helper.stringify(val2));
+ assertEquals(val2, helper.parse(str2, Short.class));
+
+ String str3 = " -12345 ";
+ Short val3 = Short.valueOf((short)-12345);
+ assertEquals(val3, helper.parse(str3, Short.class));
+
+ assertFailsConversionToObject(
+ "converted too-large value",
+ helper, "1234567", Short.class);
+
+ assertFailsConversionToObject(
+ "converted non-integer value",
+ helper, "123.45", Short.class);
+
+ assertFailsConversionToObject(
+ "converted non-numeric value",
+ helper, "ix", Short.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", Short.class);
+ }
+
+
+ public void testConvertInteger() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ assertEquals("xsd:int", helper.getXsdType(Integer.class));
+
+ String str1 = "1234567";
+ Integer val1 = Integer.valueOf(1234567);
+ assertEquals(str1, helper.stringify(val1));
+ assertEquals(val1, helper.parse(str1, Integer.class));
+
+ String str2 = "-1234567";
+ Integer val2 = Integer.valueOf(-1234567);
+ assertEquals(str2, helper.stringify(val2));
+ assertEquals(val2, helper.parse(str2, Integer.class));
+
+ String str3 = " -1234567 ";
+ Integer val3 = Integer.valueOf(-1234567);
+ assertEquals(val3, helper.parse(str3, Integer.class));
+
+ assertFailsConversionToObject(
+ "converted too-large value",
+ helper, "123456789012345", Integer.class);
+
+ assertFailsConversionToObject(
+ "converted non-integer value",
+ helper, "123.45", Integer.class);
+
+ assertFailsConversionToObject(
+ "converted non-numeric value",
+ helper, "ix", Integer.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", Integer.class);
+ }
+
+
+ public void testConvertLong() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ assertEquals("xsd:long", helper.getXsdType(Long.class));
+
+ String str1 = "1234567890";
+ Long val1 = Long.valueOf(1234567890L);
+ assertEquals(str1, helper.stringify(val1));
+ assertEquals(val1, helper.parse(str1, Long.class));
+
+ String str2 = "-1234567890";
+ Long val2 = Long.valueOf(-1234567890L);
+ assertEquals(str2, helper.stringify(val2));
+ assertEquals(val2, helper.parse(str2, Long.class));
+
+ String str3 = " -1234567890 ";
+ Long val3 = Long.valueOf(-1234567890L);
+ assertEquals(val3, helper.parse(str3, Long.class));
+
+ assertFailsConversionToObject(
+ "converted too-large value",
+ helper, "123456789012345678901234567890", Long.class);
+
+ assertFailsConversionToObject(
+ "converted non-integer value",
+ helper, "123.45", Long.class);
+
+ assertFailsConversionToObject(
+ "converted non-numeric value",
+ helper, "ix", Long.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", Long.class);
+ }
+
+
+ public void testConvertFloatDefault() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ // default float conversion is compatible with XSD type def
+ assertEquals("xsd:decimal", helper.getXsdType(Float.class));
+
+ // note: for default-format tests, strings are generated from values
+ Float val1 = Float.valueOf(1234f);
+ String str1 = val1.toString();
+ assertEquals(str1, helper.stringify(val1));
+ assertEquals(val1, helper.parse(str1, Float.class));
+
+ Float val2 = Float.valueOf(-1234f);
+ String str2 = val2.toString();
+ assertEquals(str2, helper.stringify(val2));
+ assertEquals(val2, helper.parse(str2, Float.class));
+
+ String str3 = " -1234.5 ";
+ Float val3 = Float.valueOf(-1234.5f);
+ assertEquals(val3, helper.parse(str3, Float.class));
+
+ assertFailsConversionToObject(
+ "converted non-numeric value",
+ helper, "ix", Float.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", Float.class);
+ }
+
+
+ public void testConvertFloatXsd() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper(true);
+
+ assertEquals("xsd:decimal", helper.getXsdType(Float.class));
+
+ String str1 = "1234.0";
+ Float val1 = Float.valueOf(1234f);
+ assertEquals(str1, helper.stringify(val1));
+ assertEquals(val1, helper.parse(str1, Float.class));
+
+ String str2 = "-1234.0";
+ Float val2 = Float.valueOf(-1234f);
+ assertEquals(str2, helper.stringify(val2));
+ assertEquals(val2, helper.parse(str2, Float.class));
+
+ String str3 = " -1234.5 ";
+ Float val3 = Float.valueOf(-1234.5f);
+ assertEquals(val3, helper.parse(str3, Float.class));
+
+ assertFailsConversionToObject(
+ "converted non-numeric value",
+ helper, "ix", Float.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", Float.class);
+ }
+
+
+ public void testConvertDoubleDefault() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ // default double conversion is compatible with XSD type def
+ assertEquals("xsd:decimal", helper.getXsdType(Double.class));
+
+ // note: for default-format tests, strings are generated from values
+ Double val1 = Double.valueOf(1234567890.5);
+ String str1 = val1.toString();
+ assertEquals(str1, helper.stringify(val1));
+ assertEquals(val1, helper.parse(str1, Double.class));
+
+ Double val2 = Double.valueOf(-1234567890.1);
+ String str2 = val2.toString();
+ assertEquals(str2, helper.stringify(val2));
+ assertEquals(val2, helper.parse(str2, Double.class));
+
+ String str3 = " -1234.5 ";
+ Double val3 = Double.valueOf(-1234.5);
+ assertEquals(val3, helper.parse(str3, Double.class));
+
+ assertFailsConversionToObject(
+ "converted non-numeric value",
+ helper, "ix", Double.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", Double.class);
+ }
+
+
+ public void testConvertDoubleXsd() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper(true);
+
+ assertEquals("xsd:decimal", helper.getXsdType(Double.class));
+
+ // while for XSD-format tests, we want to verify the strings
+ String str1 = "1234567890.5";
+ Double val1 = Double.valueOf(1234567890.5);
+ assertEquals(str1, helper.stringify(val1));
+ assertEquals(val1, helper.parse(str1, Double.class));
+
+ String str2 = "-1234567890.1";
+ Double val2 = Double.valueOf(-1234567890.1);
+ assertEquals(str2, helper.stringify(val2));
+ assertEquals(val2, helper.parse(str2, Double.class));
+
+ String str3 = " -1234.5 ";
+ Double val3 = Double.valueOf(-1234.5);
+ assertEquals(val3, helper.parse(str3, Double.class));
+
+ assertFailsConversionToObject(
+ "converted non-numeric value",
+ helper, "ix", Double.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", Double.class);
+ }
+
+
+ public void testConvertBigInteger() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ assertEquals("xsd:decimal", helper.getXsdType(BigInteger.class));
+
+ String str1 = "123456789012345678901234567890";
+ BigInteger val1 = new BigInteger(str1);
+ assertEquals(str1, helper.stringify(val1));
+ assertEquals(val1, helper.parse(str1, BigInteger.class));
+
+ String str2 = "-123456789012345678901234567890";
+ BigInteger val2 = new BigInteger(str2);
+ assertEquals(str2, helper.stringify(val2));
+ assertEquals(val2, helper.parse(str2, BigInteger.class));
+
+ assertFailsConversionToObject(
+ "converted non-integer value",
+ helper, "123.45", BigInteger.class);
+
+ assertFailsConversionToObject(
+ "converted non-numeric value",
+ helper, "ix", BigInteger.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", BigInteger.class);
+ }
+
+
+ public void testConvertBigDecimal() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ assertEquals("xsd:decimal", helper.getXsdType(BigDecimal.class));
+
+ String str1 = "12345678901234567890.123456789";
+ BigDecimal val1 = new BigDecimal(str1);
+ assertEquals(str1, helper.stringify(val1));
+ assertEquals(val1, helper.parse(str1, BigDecimal.class));
+
+ String str2 = "-12345678901234567890.123456789";
+ BigDecimal val2 = new BigDecimal(str2);
+ assertEquals(str2, helper.stringify(val2));
+ assertEquals(val2, helper.parse(str2, BigDecimal.class));
+
+ assertFailsConversionToObject(
+ "converted non-numeric value",
+ helper, "ix", BigDecimal.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", BigDecimal.class);
+ }
+
+
+ public void testConvertDateDefault() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper();
+
+ // default date conversion is NOT compatible with XSD type def,
+ // so this is misleading
+ assertEquals("xsd:dateTime", helper.getXsdType(Date.class));
+
+ // for default conversion, we create string from value
+ Date val1 = new Date(1247551703000L);
+ String str1 = val1.toString();
+ assertEquals(str1, helper.stringify(val1));
+ assertEquals(val1, helper.parse(str1, Date.class));
+
+
+ assertFailsConversionToObject(
+ "converted non-date value",
+ helper, "ix", Date.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", Date.class);
+ }
+
+
+ public void testConvertDateXsd() throws Exception
+ {
+ ConversionHelper helper = new ConversionHelper(true);
+
+ assertEquals("xsd:dateTime", helper.getXsdType(Date.class));
+
+ Date val1 = new Date(1247551703000L);
+ String str1 = "2009-07-14T06:08:23";
+ assertEquals(str1, helper.stringify(val1));
+ assertEquals(val1, helper.parse(str1, Date.class));
+
+ assertFailsConversionToObject(
+ "converted non-date value",
+ helper, "ix", Date.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", Date.class);
+ }
+}
Deleted: branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestPrimitiveConversionHelper.java
===================================================================
--- branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestPrimitiveConversionHelper.java 2009-08-14 19:00:11 UTC (rev 104)
+++ branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestPrimitiveConversionHelper.java 2009-08-14 20:05:39 UTC (rev 105)
@@ -1,529 +0,0 @@
-// Copyright 2008-2009 severally by the contributors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package net.sf.practicalxml.converter;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.Date;
-
-
-public class TestPrimitiveConversionHelper
-extends AbstractBeanConverterTestCase
-{
- public TestPrimitiveConversionHelper(String name)
- {
- super(name);
- }
-
-
-//----------------------------------------------------------------------------
-// Support Code
-//----------------------------------------------------------------------------
-
- private void assertFailsConversionToObject(
- String message,
- PrimitiveConversionHelper helper,
- String str,
- Class<?> klass)
- {
- try
- {
- helper.parse(str, klass);
- fail(message);
- }
- catch (ConversionException ee)
- {
- // success!
- }
- }
-
-
-//----------------------------------------------------------------------------
-// Test Cases
-//----------------------------------------------------------------------------
-
- public void testUnknownClass() throws Exception
- {
- PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
-
- assertNull(helper.getXsdType(Class.class));
- }
-
-
- public void testConvertNull() throws Exception
- {
- PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
-
- assertNull(helper.stringify(null));
- assertNull(helper.parse(null, Object.class));
- }
-
-
- public void testConvertString() throws Exception
- {
- PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
-
- assertEquals("xsd:string", helper.getXsdType(String.class));
-
- assertEquals("foo", helper.stringify("foo"));
- assertEquals("foo", helper.parse("foo", String.class));
-
- assertEquals("", helper.stringify(""));
- assertEquals("", helper.parse("", String.class));
- }
-
-
- public void testConvertCharacter() throws Exception
- {
- PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
-
- assertEquals("xsd:string", helper.getXsdType(Character.class));
-
- Character simple = Character.valueOf('A');
- assertEquals("A", helper.stringify(simple));
- assertEquals(simple, helper.parse("A", Character.class));
-
- Character nul = Character.valueOf('\0');
- assertEquals("", helper.stringify(nul));
- assertEquals(nul, helper.parse("", Character.class));
-
- assertFailsConversionToObject(
- "converted multi-character string",
- helper, "ix", Character.class);
- }
-
-
- public void testConvertBooleanDefault() throws Exception
- {
- PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
-
- // default boolean conversion is compatible with XSD type def
- assertEquals("xsd:boolean", helper.getXsdType(Boolean.class));
-
- String sTrue = Boolean.TRUE.toString();
- assertEquals(sTrue, helper.stringify(Boolean.TRUE));
- assertEquals(Boolean.TRUE, helper.parse(sTrue, Boolean.class));
-
- String sFalse = Boolean.FALSE.toString();
- assertEquals(sFalse, helper.stringify(Boolean.FALSE));
- assertEquals(Boolean.FALSE, helper.parse(sFalse, Boolean.class));
-
- assertEquals(Boolean.FALSE, helper.parse("ix", Boolean.class));
- assertEquals(Boolean.FALSE, helper.parse("", Boolean.class));
- }
-
-
- public void testConvertBooleanXsd() throws Exception
- {
- PrimitiveConversionHelper helper = new PrimitiveConversionHelper(true);
-
- assertEquals("xsd:boolean", helper.getXsdType(Boolean.class));
-
- assertEquals("true", helper.stringify(Boolean.TRUE));
- assertEquals(Boolean.TRUE, helper.parse("true", Boolean.class));
- assertEquals(Boolean.TRUE, helper.parse("1", Boolean.class));
-
- assertEquals("false", helper.stringify(Boolean.FALSE));
- assertEquals(Boolean.FALSE, helper.parse("false", Boolean.class));
- assertEquals(Boolean.FALSE, helper.parse("0", Boolean.class));
-
- assertFailsConversionToObject(
- "converted multi-character string",
- helper, "ix", Boolean.class);
-
- assertFailsConversionToObject(
- "converted empty string",
- helper, "", Boolean.class);
- }
-
-
- public void testConvertByte() throws Exception
- {
- PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
-
- assertEquals("xsd:byte", helper.getXsdType(Byte.class));
-
- String str1 = "123";
- Byte val1 = Byte.valueOf((byte)123);
- assertEquals(str1, helper.stringify(val1));
- assertEquals(val1, helper.parse(str1, Byte.class));
-
- String str2 = "-123";
- Byte val2 = Byte.valueOf((byte)-123);
- assertEquals(str2, helper.stringify(val2));
- assertEquals(val2, helper.parse(str2, Byte.class));
-
- String str3 = " -123 ";
- Byte val3 = Byte.valueOf((byte)-123);
- assertEquals(val3, helper.parse(str3, Byte.class));
-
- assertFailsConversionToObject(
- "converted too-large value",
- helper, "1234567", Byte.class);
-
- assertFailsConversionToObject(
- "converted non-integer value",
- helper, "1.23", Byte.class);
-
- assertFailsConversionToObject(
- "converted non-numeric value",
- helper, "ix", Byte.class);
-
- assertFailsConversionToObject(
- "converted empty string",
- helper, "", Byte.class);
- }
-
-
- public void testConvertShort() throws Exception
- {
- PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
-
- assertEquals("xsd:short", helper.getXsdType(Short.class));
-
- String str1 = "12345";
- Short val1 = Short.valueOf((short)12345);
- assertEquals(str1, helper.stringify(val1));
- assertEquals(val1, helper.parse(str1, Short.class));
-
- String str2 = "-12345";
- Short val2 = Short.valueOf((short)-12345);
- assertEquals(str2, helper.stringify(val2));
- assertEquals(val2, helper.parse(str2, Short.class));
-
- String str3 = " -12345 ";
- Short val3 = Short.valueOf((short)-12345);
- assertEquals(val3, helper.parse(str3, Short.class));
-
- assertFailsConversionToObject(
- "converted too-large value",
- helper, "1234567", Short.class);
-
- assertFailsConversionToObject(
- "converted non-integer value",
- helper, "123.45", Short.class);
-
- assertFailsConversionToObject(
- "converted non-numeric value",
- helper, "ix", Short.class);
-
- assertFailsConversionToObject(
- "converted empty string",
- helper, "", Short.class);
- }
-
-
- public void testConvertInteger() throws Exception
- {
- PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
-
- assertEquals("xsd:int", helper.getXsdType(Integer.class));
-
- String str1 = "1234567";
- Integer val1 = Integer.valueOf(1234567);
- assertEquals(str1, helper.stringify(val1));
- assertEquals(val1, helper.parse(str1, Integer.class));
-
- String str2 = "-1234567";
- Integer val2 = Integer.valueOf(-1234567);
- assertEquals(str2, helper.stringify(val2));
- assertEquals(val2, helper.parse(str2, Integer.class));
-
- String str3 = " -1234567 ";
- Integer val3 = Integer.valueOf(-1234567);
- assertEquals(val3, helper.parse(str3, Integer.class));
-
- assertFailsConversionToObject(
- "converted too-large value",
- helper, "123456789012345", Integer.class);
-
- assertFailsConversionToObject(
- "converted non-integer value",
- helper, "123.45", Integer.class);
-
- assertFailsConversionToObject(
- "converted non-numeric value",
- helper, "ix", Integer.class);
-
- assertFailsConversionToObject(
- "converted empty string",
- helper, "", Integer.class);
- }
-
-
- public void testConvertLong() throws Exception
- {
- PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
-
- assertEquals("xsd:long", helper.getXsdType(Long.class));
-
- String str1 = "1234567890";
- Long val1 = Long.valueOf(1234567890L);
- assertEquals(str1, helper.stringify(val1));
- assertEquals(val1, helper.parse(str1, Long.class));
-
- String str2 = "-1234567890";
- Long val2 = Long.valueOf(-1234567890L);
- assertEquals(str2, helper.stringify(val2));
- assertEquals(val2, helper.parse(str2, Long.class));
-
- String str3 = " -1234567890 ";
- Long val3 = Long.valueOf(-1234567890L);
- assertEquals(val3, helper.parse(str3, Long.class));
-
- assertFailsConversionToObject(
- "converted too-large value",
- helper, "123456789012345678901234567890", Long.class);
-
- assertFailsConversionToObject(
- "converted non-integer value",
- helper, "123.45", Long.class);
-
- assertFailsConversionToObject(
- "converted non-numeric value",
- helper, "ix", Long.class);
-
- assertFailsConversionToObject(
- "converted empty string",
- helper, "", Long.class);
- }
-
-
- public void testConvertFloatDefault() throws Exception
- {
- PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
-
- // default float conversion is compatible with XSD type def
- assertEquals("xsd:decimal", helper.getXsdType(Float.class));
-
- // note: for default-format tests, strings are generated from values
- Float val1 = Float.valueOf(1234f);
- String str1 = val1.toString();
- assertEquals(str1, helper.stringify(val1));
- assertEquals(val1, helper.parse(str1, Float.class));
-
- Float val2 = Float.valueOf(-1234f);
- String str2 = val2.toString();
- assertEquals(str2, helper.stringify(val2));
- assertEquals(val2, helper.parse(str2, Float.class));
-
- String str3 = " -1234.5 ";
- Float val3 = Float.valueOf(-1234.5f);
- assertEquals(val3, helper.parse(str3, Float.class));
-
- assertFailsConversionToObject(
- "converted non-numeric value",
- helper, "ix", Float.class);
-
- assertFailsConversionToObject(
- "converted empty string",
- helper, "", Float.class);
- }
-
-
- public void testConvertFloatXsd() throws Exception
- {
- PrimitiveConversionHelper helper = new PrimitiveConversionHelper(true);
-
- assertEquals("xsd:decimal", helper.getXsdType(Float.class));
-
- String str1 = "1234.0";
- Float val1 = Float.valueOf(1234f);
- assertEquals(str1, helper.stringify(val1));
- assertEquals(val1, helper.parse(str1, Float.class));
-
- String str2 = "-1234.0";
- Float val2 = Float.valueOf(-1234f);
- assertEquals(str2, helper.stringify(val2));
- assertEquals(val2, helper.parse(str2, Float.class));
-
- String str3 = " -1234.5 ";
- Float val3 = Float.valueOf(-1234.5f);
- assertEquals(val3, helper.parse(str3, Float.class));
-
- assertFailsConversionToObject(
- ...
[truncated message content] |
