[Practicalxml-commits] SF.net SVN: practicalxml:[98] branches/dev-1.1/src
Brought to you by:
kdgregory
Menu
▾
▴
[Practicalxml-commits] SF.net SVN: practicalxml:[98] branches/dev-1.1/src
|
From: Auto-Generated S. C. M. <pra...@li...> - 2009-08-12 20:35:45
|
Revision: 98
http://practicalxml.svn.sourceforge.net/practicalxml/?rev=98&view=rev
Author: kdgregory
Date: 2009-08-12 20:35:22 +0000 (Wed, 12 Aug 2009)
Log Message:
-----------
checkpoint - flesh out parsing options, move primitive conversion to own class
Modified Paths:
--------------
branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/Bean2XmlHandler.java
branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/Xml2BeanHandler.java
branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/Xml2BeanOptions.java
branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestXml2BeanHandler.java
Added 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
Modified: branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/Bean2XmlHandler.java
===================================================================
--- branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/Bean2XmlHandler.java 2009-08-10 22:30:50 UTC (rev 97)
+++ branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/Bean2XmlHandler.java 2009-08-12 20:35:22 UTC (rev 98)
@@ -17,6 +17,7 @@
import net.sf.practicalxml.DomUtil;
import net.sf.practicalxml.XmlUtil;
+import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Date;
import java.util.EnumSet;
@@ -46,6 +47,7 @@
{
private EnumSet<Bean2XmlOptions> _options;
private Appender _appender;
+ private PrimitiveConversionHelper _primitiveHelper;
/**
@@ -54,10 +56,13 @@
*/
public Bean2XmlHandler(Element appendTo, Bean2XmlOptions... options)
{
- _appender = new Appender(appendTo);
_options = EnumSet.noneOf(Bean2XmlOptions.class);
for (Bean2XmlOptions option : options)
_options.add(option);
+
+ _appender = new Appender(appendTo);
+
+ _primitiveHelper = new PrimitiveConversionHelper(shouldFormatAsXsd());
}
@@ -68,6 +73,7 @@
{
_appender = appender;
_options = parent._options;
+ _primitiveHelper = parent._primitiveHelper;
}
@@ -77,83 +83,69 @@
public void convert(String name, Boolean value)
{
- Object formatted = value;
- if (shouldFormatAsXsd())
- formatted = value.booleanValue() ? "true" : "false";
-
- _appender.append(name, "xsd:boolean", formatted);
+ appendPrimitive(name, Boolean.class, value);
}
public void convert(String name, Byte value)
{
- _appender.append(name, "xsd:byte", value);
+ appendPrimitive(name, Byte.class, value);
}
public void convert(String name, Character value)
{
- _appender.append(name, "xsd:string", value);
+ appendPrimitive(name, Character.class, value);
}
public void convert(String name, Date value)
{
- Object formatted = value;
- if (shouldFormatAsXsd())
- formatted = XmlUtil.formatXsdDatetime(value);
-
- _appender.append(name, "xsd:dateTime", formatted);
+ appendPrimitive(name, Date.class, value);
}
public void convert(String name, Double value)
{
- Object formatted = value;
- if (shouldFormatAsXsd())
- formatted = XmlUtil.formatXsdDecimal(value);
-
- _appender.append(name, "xsd:decimal", formatted);
+ appendPrimitive(name, Double.class, value);
}
public void convert(String name, Float value)
{
- Object formatted = value;
- if (shouldFormatAsXsd())
- formatted = XmlUtil.formatXsdDecimal(value);
-
- _appender.append(name, "xsd:decimal", formatted);
+ appendPrimitive(name, Float.class, value);
}
public void convert(String name, Integer value)
{
- _appender.append(name, "xsd:int", value);
+ appendPrimitive(name, Integer.class, value);
}
public void convert(String name, Long value)
{
- _appender.append(name, "xsd:long", value);
+ appendPrimitive(name, Long.class, value);
}
+ // FIXME - passes tests but not pretty ...
+ // the multitude of convert methods will go away, however
public void convert(String name, Number value)
{
- _appender.append(name, "xsd:decimal", value);
+ appendPrimitive(name, BigDecimal.class, value);
}
public void convert(String name, Short value)
{
- _appender.append(name, "xsd:short", value);
+ appendPrimitive(name, Short.class, value);
}
public void convert(String name, String value)
{
- _appender.append(name, "xsd:string", value);
+ appendPrimitive(name, String.class, value);
}
@@ -229,6 +221,19 @@
/**
+ * Common code for primitive objects.
+ */
+ public void appendPrimitive(String name, Class<?> klass, Object value)
+ {
+ String xsdType = _primitiveHelper.getXsdType(klass);
+ if (xsdType == null)
+ throw new ConversionException("internal error: " + klass.getName()
+ + " passed as primitive");
+ _appender.append(name, xsdType, _primitiveHelper.stringify(value));
+ }
+
+
+ /**
* Common code for sequenced objects -- arrays, lists, and sets.
*/
private void appendSequence(Element parent, Iterator<?> itx, boolean isIndexed)
Added: 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 (rev 0)
+++ branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/PrimitiveConversionHelper.java 2009-08-12 20:35:22 UTC (rev 98)
@@ -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 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.getXsdType();
+ }
+
+
+ /**
+ * 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 getXsdType();
+ public String stringify(T obj) throws Exception;
+ public T parse(String str) throws Exception;
+ }
+
+
+ private class StringConversionHandler
+ implements ConversionHandler<String>
+ {
+ public String getXsdType()
+ {
+ 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 getXsdType()
+ {
+ 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 getXsdType()
+ {
+ 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 getXsdType()
+ {
+ 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 getXsdType()
+ {
+ 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 getXsdType()
+ {
+ 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 getXsdType()
+ {
+ 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 getXsdType()
+ {
+ 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 getXsdType()
+ {
+ 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 getXsdType()
+ {
+ 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 getXsdType()
+ {
+ 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 getXsdType()
+ {
+ 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/Xml2BeanHandler.java
===================================================================
--- branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/Xml2BeanHandler.java 2009-08-10 22:30:50 UTC (rev 97)
+++ branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/Xml2BeanHandler.java 2009-08-12 20:35:22 UTC (rev 98)
@@ -15,7 +15,9 @@
package net.sf.practicalxml.converter;
import net.sf.practicalxml.DomUtil;
+import net.sf.practicalxml.XmlException;
import net.sf.practicalxml.XmlUtil;
+import net.sf.practicalxml.internal.StringUtils;
import java.util.Arrays;
import java.util.Date;
@@ -38,6 +40,7 @@
public class Xml2BeanHandler
{
private EnumSet<Xml2BeanOptions> _options;
+ private PrimitiveConversionHelper _primitiveHelper;
/**
@@ -48,6 +51,8 @@
_options = EnumSet.noneOf(Xml2BeanOptions.class);
for (Xml2BeanOptions option : options)
_options.add(option);
+
+ _primitiveHelper = new PrimitiveConversionHelper(true);
}
@@ -55,27 +60,21 @@
// Public Methods
//----------------------------------------------------------------------------
-
public Boolean convertBoolean(Element elem)
{
- String text = DomUtil.getText(elem);
- return Boolean.valueOf(XmlUtil.parseXsdBoolean(text));
+ return (Boolean)_primitiveHelper.parse(getText(elem), Boolean.class);
}
public Byte convertByte(Element elem)
{
- String text = DomUtil.getText(elem);
- return Byte.valueOf(text);
+ return (Byte)_primitiveHelper.parse(getText(elem), Byte.class);
}
public Character convertCharacter(Element elem)
{
- String text = DomUtil.getText(elem);
- if (text.length() == 0)
- return '\0';
- return Character.valueOf(text.charAt(0));
+ return (Character)_primitiveHelper.parse(getText(elem), Character.class);
}
@@ -87,29 +86,25 @@
public Double convertDouble(Element elem)
{
- String text = DomUtil.getText(elem);
- return Double.valueOf(text);
+ return (Double)_primitiveHelper.parse(getText(elem), Double.class);
}
public Float convertFloat(Element elem)
{
- String text = DomUtil.getText(elem);
- return Float.valueOf(text);
+ return (Float)_primitiveHelper.parse(getText(elem), Float.class);
}
public Integer convertInteger(Element elem)
{
- String text = DomUtil.getText(elem);
- return Integer.valueOf(text);
+ return (Integer)_primitiveHelper.parse(getText(elem), Integer.class);
}
public Long convertLong(Element elem)
{
- String text = DomUtil.getText(elem);
- return Long.valueOf(text);
+ return (Long)_primitiveHelper.parse(getText(elem), Long.class);
}
@@ -121,15 +116,13 @@
public Short convertShort(Element elem)
{
- String text = DomUtil.getText(elem);
- return Short.valueOf(text);
+ return (Short)_primitiveHelper.parse(getText(elem), Short.class);
}
public String convertString(Element elem)
{
- String text = DomUtil.getText(elem);
- return text;
+ return (String)_primitiveHelper.parse(getText(elem), String.class);
}
@@ -167,5 +160,33 @@
// Internals
//----------------------------------------------------------------------------
+ /**
+ * Returns the text from a passed element, applying any low-level options
+ * along the way.
+ */
+ private String getText(Element elem)
+ {
+ String text = DomUtil.getText(elem);
+ if (_options.contains(Xml2BeanOptions.CONVERT_BLANK_AS_NULL) && StringUtils.isBlank(text))
+ text = null;
+ validateXsiNil(elem, text);
+ return text;
+ }
+
+ /**
+ * Checks for elements that require <code>xsi:nil</code>, and throws if missing.
+ */
+ private void validateXsiNil(Element elem, String text)
+ {
+ if (text != null)
+ return;
+ if (!_options.contains(Xml2BeanOptions.REQUIRE_XSI_NIL))
+ return;
+
+ String attr = elem.getAttributeNS(XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI, "nil");
+ if ((attr == null) || !attr.equals("true"))
+ throw new ConversionException("empty element without required xsi:nil");
+ }
+
}
Modified: branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/Xml2BeanOptions.java
===================================================================
--- branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/Xml2BeanOptions.java 2009-08-10 22:30:50 UTC (rev 97)
+++ branches/dev-1.1/src/main/java/net/sf/practicalxml/converter/Xml2BeanOptions.java 2009-08-12 20:35:22 UTC (rev 98)
@@ -22,6 +22,14 @@
public enum Xml2BeanOptions
{
/**
+ * If present, the converter will treat all elements with empty text nodes
+ * as if they were empty elements -- in other words, <code>null</code>.
+ * Note that this flag will interact with <code>REQUIRE_XSI_NIL</code>.
+ */
+ CONVERT_BLANK_AS_NULL,
+
+
+ /**
* If present, the converter ignores elements that don't correspond to
* settable properties of the bean.
*/
@@ -37,19 +45,27 @@
/**
+ * If present, the converter will use a setter method taking a String, in
+ * preference to any other type. Default behavior is to pick the method
+ * with the most restrictive type (and considering numeric types as more
+ * restrictive than <code>String</code>).
+ */
+ PREFER_STRING_SETTER,
+
+
+ /**
+ * If present, the converter requires an <code>xsi:nil</code> attribute
+ * on any empty nodes, and will throw if it's not present. Default is to
+ * treat empty nodes as <code>null</code>.
+ */
+ REQUIRE_XSI_NIL,
+
+
+ /**
* If present, the converter requires an <code>xsi:type</code> attribute
* on each element, and will throw if it's not present. Default behavior
* uses the <code>xsi:type</code> value to choose between different setter
* methods, but otherwise ignores it.
*/
- REQUIRE_XSI_TYPE,
-
-
- /**
- * If present, the converter will use a setter method taking a String, in
- * preference to any other type. Default behavior is to pick the method
- * with the most restrictive type (and considering numeric types as more
- * restrictive than <code>String</code>).
- */
- PREFER_STRING_SETTER
+ REQUIRE_XSI_TYPE
}
Added: 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 (rev 0)
+++ branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestPrimitiveConversionHelper.java 2009-08-12 20:35:22 UTC (rev 98)
@@ -0,0 +1,510 @@
+// Copyright (c) Keith D Gregory, all rights reserved
+package net.sf.practicalxml.converter;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Date;
+
+import junit.framework.TestCase;
+
+public class TestPrimitiveConversionHelper extends TestCase
+{
+//----------------------------------------------------------------------------
+// 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(
+ "converted non-numeric value",
+ helper, "ix", Float.class);
+
+ assertFailsConversionToObject(
+ "converted empty string",
+ helper, "", Float.class);
+ }
+
+
+ public void testConvertDoubleDefault() throws Exception
+ {
+ PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
+
+ // 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
+ {
+ PrimitiveConversionHelper helper = new PrimitiveConversionHelper(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
+ {
+ PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
+
+ 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
+ {
+ PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
+
+ 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
+ {
+ PrimitiveConversionHelper helper = new PrimitiveConversionHelper();
+
+ // 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
+ {
+ PrimitiveConversionHelper helper = new PrimitiveConversionHelper(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);
+ }
+}
Modified: branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestXml2BeanHandler.java
===================================================================
--- branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestXml2BeanHandler.java 2009-08-10 22:30:50 UTC (rev 97)
+++ branches/dev-1.1/src/test/java/net/sf/practicalxml/converter/TestXml2BeanHandler.java 2009-08-12 20:35:22 UTC (rev 98)
@@ -14,9 +14,13 @@
package net.sf.practicalxml.converter;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import javax.xml.XMLConstants;
import org.w3c.dom.Element;
-
+import net.sf.practicalxml.DomUtil;
import net.sf.practicalxml.builder.XmlBuilder;
@@ -40,16 +44,72 @@
*/
private Element createElement(String data)
{
- return XmlBuilder.element("data", XmlBuilder.text(data))
- .toDOM().getDocumentElement();
+ Element elem = XmlBuilder.element("data").toDOM().getDocumentElement();
+ if (data != null)
+ DomUtil.appendText(elem, data);
+ return elem;
}
+ /**
+ * Reflectively executes the named method, and asserts that it throws
+ * a conversion exception. This method exists to keep clutter out of
+ * the test methods.
+ */
+ private void assertConversionFailure(
+ Xml2BeanHandler handler, String methodName,
+ Element elem, String failureText)
+ throws Exception
+ {
+ Method method = handler.getClass().getMethod(methodName, Element.class);
+ try
+ {
+ method.invoke(handler, elem);
+ fail(methodName + ": " + failureText);
+ }
+ catch (InvocationTargetException ee)
+ {
+ if (ee.getCause().getClass() != ConversionException.class)
+ fail(methodName + "threw unexpected exception: " + ee.getCause());
+ // otherwise, we're successful
+ }
+ }
+
+
//----------------------------------------------------------------------------
// Test Cases
//----------------------------------------------------------------------------
+ public void testConvertString() throws Exception
+ {
+ Xml2BeanHandler handler = new Xml2BeanHandler();
+ Element data1 = createElement("foo");
+ assertEquals("foo", handler.convertString(data1));
+
+ Element data2 = createElement("");
+ assertEquals("", handler.convertString(data2));
+ }
+
+
+ public void testConvertCharacter() throws Exception
+ {
+ Xml2BeanHandler handler = new Xml2BeanHandler();
+
+ Element data1 = createElement("A");
+ assertEquals(Character.valueOf('A'), handler.convertCharacter(data1));
+
+ Element data2 = createElement("\uFB01");
+ assertEquals(Character.valueOf('\uFB01'), handler.convertCharacter(data2));
+
+ Element data3 = createElement("");
+ assertEquals(Character.valueOf('\0'), handler.convertCharacter(data3));
+
+ Element data4 = createElement("ix");
+ assertConversionFailure(handler, "convertCharacter", data4, "converted invalid value");
+ }
+
+
public void testConvertBoolean() throws Exception
{
Xml2BeanHandler handler = new Xml2BeanHandler();
@@ -66,7 +126,11 @@
Element data4 = createElement("0");
assertEquals(Boolean.FALSE, handler.convertBoolean(data4));
- // FIXME - test failure
+ Element data5 = createElement("ix");
+ assertConversionFailure(handler, "convertBoolean", data5, "converted invalid value");
+
+ Element data6 = createElement("");
+ assertConversionFailure(handler, "convertBoolean", data6, "converted empty value");
}
@@ -80,73 +144,116 @@
Element data2 = createElement("-123");
assertEquals(Byte.valueOf((byte)-123), handler.convertByte(data2));
- // FIXME - test failure
+ Element data3 = createElement("ix");
+ assertConversionFailure(handler, "convertByte", data3, "converted invalid value");
+
+ Element data4 = createElement("1234567");
+ assertConversionFailure(handler, "convertByte", data4, "converted too-large value");
+
+ Element data5 = createElement("");
+ assertConversionFailure(handler, "convertByte", data5, "converted empty value");
}
- public void testConvertCharacter() throws Exception
+ public void testConvertShort() throws Exception
{
Xml2BeanHandler handler = new Xml2BeanHandler();
- Element data1 = createElement("A");
- assertEquals(Character.valueOf('A'), handler.convertCharacter(data1));
+ Element data1 = createElement("12345");
+ assertEquals(Short.valueOf((short)12345), handler.convertShort(data1));
- Element data2 = createElement("\uFB01");
- assertEquals(Character.valueOf('\uFB01'), handler.convertCharacter(data2));
+ Element data2 = createElement("-12345");
+ assertEquals(Short.valueOf((short)-12345), handler.convertShort(data2));
- Element data3 = createElement("");
- assertEquals(Character.valueOf('\0'), handler.convertCharacter(data3));
+ Element data3 = createElement("ix");
+ assertConversionFailure(handler, "convertShort", data3, "converted non-numeric value");
- // FIXME - test failure -- multi-character?
- }
+ Element data4 = createElement("1234567");
+ assertConversionFailure(handler, "convertShort", data4, "converted too-large value");
+ Element data5 = createElement("123.45");
+ assertConversionFailure(handler, "convertShort", data5, "converted non-integer value");
-// public void testConvertDate() throws Exception
-// {
-// }
+ Element data6 = createElement("");
+ assertConversionFailure(handler, "convertShort", data6, "converted empty value");
+ }
- public void testConvertDouble() throws Exception
+ public void testConvertInteger() throws Exception
{
Xml2BeanHandler handler = new Xml2BeanHandler();
- Element data = createElement("1234567890.125");
- assertEquals(Double.valueOf(1234567890.125), handler.convertDouble(data));
+ Element data1 = createElement("123456789");
+ assertEquals(Integer.valueOf(123456789), handler.convertInteger(data1));
- // FIXME - test failure
+ Element data2 = createElement("-123456789");
+ assertEquals(Integer.valueOf(-123456789), handler.convertInteger(data2));
+
+ Element data3 = createElement("ix");
+ assertConversionFailure(handler, "convertInteger", data3, "converted non-numeric value");
+
+ Element data4 = createElement("123456789012345");
+ assertConversionFailure(handler, "convertInteger", data4, "converted too-large value");
+
+ Element data5 = createElement("123.45");
+ assertConversionFailure(handler, "convertInteger", data5, "converted non-integer value");
+
+ Element data6 = createElement("");
+ assertConversionFailure(handler, "convertInteger", data6, "converted empty value");
}
- public void testConvertFloat() throws Exception
+ public void testConvertLong() throws Exception
{
Xml2BeanHandler handler = new Xml2BeanHandler();
- Element data = createElement("1234.5");
- assertEquals(Float.valueOf((float)1234.5), handler.convertFloat(data));
+ Element data1 = createElement("1234567890123456");
+ assertEquals(Long.valueOf(1234567890123456L), handler.convertLong(data1));
- // FIXME - test failure
+ Element data2 = createElement("-1234567890123456");
+ assertEquals(Long.valueOf(-1234567890123456L), handler.convertLong(data2));
+
+ Element data3 = createElement("ix");
+ assertConversionFailure(handler, "convertLong", data3, "converted non-numeric value");
+
+ Element data4 = createElement("123456789012345123456789012345");
+ assertConversionFailure(handler, "convertLong", data4, "converted too-large value");
+
+ Element data5 = createElement("123.45");
+ assertConversionFailure(handler, "convertLong", data5, "converted non-integer value");
+
+ Element data6 = createElement("");
+ assertConversionFailure(handler, "convertLong", data6, "converted empty value");
}
- public void testConvertInteger() throws Exception
+ public void testConvertFloat() throws Exception
{
Xml2BeanHandler handler = new Xml2BeanHandler();
- Element data = createElement("123456789");
- assertEquals(Integer.valueOf(123456789), handler.convertInteger(data));
+ Element data1 = createElement("1234.5");
+ assertEquals(Float.valueOf((float)1234.5), handler.convertFloat(data1));
- // FIXME - test failure
+ Element data2 = createElement("ix");
+ assertConversionFailure(handler, "convertFloat", data2, "converted non-numeric value");
+
+ Element data3 = createElement("");
+ assertConversionFailure(handler, "convertFloat", data3, "converted empty value");
}
- public void testConvertLong() throws Exception
+ public void testConvertDouble() throws Exception
{
Xml2BeanHandler handler = new Xml2BeanHandler();
- Element data = createElement("1234567890123456");
- assertEquals(Long.valueOf(1234567890123456L), handler.convertLong(data));
+ Element data1 = createElement("1234567890.125");
+ assertEquals(Double.valueOf(1234567890.125), handler.convertDouble(data1));
- // FIXME - test failure
+ Element data2 = createElement("ix");
+ assertConversionFailure(handler, "convertDouble", data2, "converted non-numeric value");
+
+ Element data3 = createElement("");
+ assertConversionFailure(handler, "convertDouble", data3, "converted empty value");
}
@@ -155,25 +262,11 @@
// }
- public void testConvertShort() throws Exception
- {
- Xml2BeanHandler handler = new Xml2BeanHandler();
+// public void testConvertDate() throws Exception
+// {
+// }
- Element data = createElement("12345");
- assertEquals(Short.valueOf((short)12345), handler.convertShort(data));
- // FIXME - test failure
- }
-
-
- public void testConvertString() throws Exception
- {
- Xml2BeanHandler handler = new Xml2BeanHandler();
-
- Element data = createElement("foo");
- assertEquals("foo", handler.convertString(data));
- }
-
// public void testConvertList() throws Exception
// {
// }
@@ -197,4 +290,118 @@
// public void testConvertObjectArray() throws Exception
// {
// }
+
+
+ public void testConvertNull() throws Exception
+ {
+ Xml2BeanHandler handler = new Xml2BeanHandler();
+
+ Element nullData = createElement(null);
+
+ assertNull(handler.convertString(nullData));
+ assertNull(handler.convertCharacter(nullData));
+ assertNull(handler.convertBoolean(nullData));
+ assertNull(handler.convertByte(nullData));
+ assertNull(handler.convertShort(nullData));
+ assertNull(handler.convertInteger(nullData));
+ assertNull(handler.convertLong(nullData));
+ assertNull(handler.convertFloat(nullData));
+ assertNull(handler.convertDouble(nullData));
+// assertNull(handler.convertNumber(nullData)); FIXME
+// assertNull(handler.convertDate(nullData)); FIXME
+// assertNull(handler.convertList(nullData)); FIXME
+// assertNull(handler.convertMap(nullData)); FIXME
+// assertNull(handler.convertSet(nullData)); FIXME
+// assertNull(handler.convertObject(nullData)); FIXME
+// assertNull(handler.convertObjectArray(nullData)); FIXME
+ }
+
+
+ public void testConvertEmptyAsNull() throws Exception
+ {
+ Xml2BeanHandler handler = new Xml2BeanHandler(Xml2BeanOptions.CONVERT_BLANK_AS_NULL);
+
+ Element empty = createElement(null);
+
+ assertNull(handler.convertString(empty));
+ assertNull(handler.convertCharacter(empty));
+ assertNull(handler.convertBoolean(empty));
+ assertNull(handler.convertByte(empty));
+ assertNull(handler.convertShort(empty));
+ assertNull(handler.convertInteger(empty));
+ assertNull(handler.convertLong(empty));
+ assertNull(handler.convertFloat(empty));
+ assertNull(handler.convertDouble(empty));
+// assertNull(handler.convertNumber(empty)); FIXME
+// assertNull(handler.convertDate(empty)); FIXME
+// assertNull(handler.convertList(empty)); FIXME
+// assertNull(handler.convertMap(empty)); FIXME
+// assertNull(handler.convertSet(empty)); FIXME
+// assertNull(handler.convertObject(empty)); FIXME
+// assertNull(handler.convertObjectArray(empty)); FIXME
+
+ Element blank = createElement(" \t\n ");
+
+ assertNull(handler.convertString(blank));
+ assertNull(handler.convertCharacter(blank));
+ assertNull(handler.convertBoolean(blank));
+ assertNull(handler.convertByte(blank));
+ assertNull(handler.convertShort(blank));
+ assertNull(handler.convertInteger(blank));
+ assertNull(handler.convertLong(blank));
+ assertNull(handler.convertFloat(blank));
+ assertNull(handler.convertDouble(blank));
+// assertNull(handler.convertNumber(blank)); FIXME
+// assertNull(handler.convertDate(blank)); FIXME
+// assertNull(handler.convertList(blank)); FIXME
+// assertNull(handler.convertMap(blank)); FIXME
+// assertNull(handler.convertSet(blank)); FIXME
+// assertNull(handler.convertObject(blank)); FIXME
+// assertNull(handler.convertObjectArray(blank)); FIXME
+ }
+
+
+ public void testRequireXsiNil() throws Exception
+ {
+ Xml2BeanHandler handler = new Xml2BeanHandler(Xml2BeanOptions.REQUIRE_XSI_NIL);
+
+ Element badData = createElement(null);
+
+ assertConversionFailure(handler, "convertString", badData, "converted empty without xsi:nil");
+ assertConversionFailure(handler, "convertCharacter", badData, "converted empty without xsi:nil");
+ assertConversionFailure(handler, "convertBoolean", badData, "converted empty without xsi:nil");
+ assertConversionFailure(handler, "convertByte", badData, "converted empty without xsi:nil");
+ assertConversionFailure(handler, "convertShort", badData, "converted empty without xsi:nil");
+ assertConversionFailure(handler, "convertInteger", badData, "converted empty without xsi:nil");
+ assertConversionFailure(handler, "convertLong", badData, "converted empty without xsi:nil");
+ assertConversionFailure(handler, "convertFloat", badData, "converted empty without xsi:nil");
+ assertConversionFailure(handler, "convertDouble", badData, "converted empty without xsi:nil");
+// assertConversionFailure(handler, "convertNumber", badData, "converted empty without xsi:nil"); FIXME
+// assertConversionFailure(handler, "convertDate", badData, "converted empty without xsi:nil"); FIXME
+// assertConversionFailure(handler, "convertList", badData, "converted empty without xsi:nil"); FIXME
+// assertConversionFailure(handler, "convertMap", badData, "converted empty without xsi:nil"); FIXME
+// assertConversionFailure(handler, "convertSet", badData, "converted empty without xsi:nil"); FIXME
+// assertConversionFailure(handler, "convertObject", badData, "converted empty without xsi:nil"); FIXME
+// assertConversionFailure(handler, "convertObjectArray", badData, "converted empty without xsi:nil"); FIXME
+
+ Element goodData = createElement(null);
+ goodData.setAttributeNS(XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI, "nil", "true");
+
+ assertNull(handler.convertString(goodData));
+ assertNull(handler.convertCharacter(goodData));
+ assertNull(handler.convertBoolean(goodData));
+ assertNull(handler.convertByte(goodData));
+ assertNull(handler.convertShort(goodData));
+ assertNull(handler.convertInteger(goodData));
+ assertNull(handler.convertLong(goodData));
+ assertNull(handler.convertFloat(goodData));
+ assertNull(handler.convertDouble(goodData));
+// assertNull(handler.convertNumber(goodData)); FIXME
+// assertNull(handler.convertDate(goodData)); FIXME
+// assertNull(handler.convertList(goodData)); FIXME
+// assertNull(handler.convertMap(goodData)); FIXME
+// assertNull(handler.convertSet(goodData)); FIXME
+// assertNull(handler.convertObject(goodData)); FIXME
+// assertNull(handler.convertObjectArray(goodData)); FIXME
+ }
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
