RemotingTest.java

/*
 * JBoss, Home of Professional Open Source
 *
 * Distributable under LGPL license.
 * See terms of license at gnu.org.
 */
package org.jboss.seam.test.unit;

import static org.testng.Assert.assertEquals;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

import org.dom4j.Document;
import org.dom4j.DocumentFactory;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.jboss.seam.contexts.Lifecycle;
import org.jboss.seam.contexts.ServletLifecycle;
import org.jboss.seam.init.Initialization;
import org.jboss.seam.mock.MockServletContext;
import org.jboss.seam.remoting.Call;
import org.jboss.seam.remoting.CallContext;
import org.jboss.seam.remoting.InterfaceGenerator;
import org.jboss.seam.remoting.MarshalUtils;
import org.jboss.seam.remoting.client.ParserUtils;
import org.jboss.seam.remoting.wrapper.BagWrapper;
import org.jboss.seam.remoting.wrapper.BaseWrapper;
import org.jboss.seam.remoting.wrapper.BeanWrapper;
import org.jboss.seam.remoting.wrapper.BooleanWrapper;
import org.jboss.seam.remoting.wrapper.ConversionException;
import org.jboss.seam.remoting.wrapper.ConversionScore;
import org.jboss.seam.remoting.wrapper.DateWrapper;
import org.jboss.seam.remoting.wrapper.MapWrapper;
import org.jboss.seam.remoting.wrapper.NullWrapper;
import org.jboss.seam.remoting.wrapper.NumberWrapper;
import org.jboss.seam.remoting.wrapper.StringWrapper;
import org.jboss.seam.remoting.wrapper.WrapperFactory;
import org.testng.annotations.Test;

/**
 * Unit tests for Seam Remoting
 * 
 * @author Shane Bryzak
 */
public class RemotingTest
{
   private class InvalidClass
   {
   }

   public Element createElement(String name, String value)
         throws UnsupportedEncodingException
   {
      Element e = DocumentFactory.getInstance().createElement(name);
      if (value != null)
         e.addText(URLEncoder.encode(value, StringWrapper.DEFAULT_ENCODING));
      return e;
   }

   private enum TestEnum
   {
      red, green, blue
   }

   @Test
   public void testBooleanWrapper() throws Exception
   {
      BooleanWrapper wrapper = new BooleanWrapper();
      wrapper.setElement(createElement("bool", Boolean.toString(true)));

      assert (Boolean) wrapper.convert(Boolean.class);
      assert (Boolean) wrapper.convert(Boolean.TYPE);

      try
      {
         // Try an invalid conversion
         wrapper.convert(InvalidClass.class);
         assert false;
      }
      catch (ConversionException ex)
      {
      }

      // test the marshal() method
      ByteArrayOutputStream out = new ByteArrayOutputStream();
      wrapper.marshal(out);
      byte[] expected = ("<bool>" + Boolean.toString(true) + "</bool>")
            .getBytes();
      assertEquals(expected, out.toByteArray());

      // test the conversionScore() method
      assert ConversionScore.exact == wrapper.conversionScore(Boolean.class);
      assert ConversionScore.exact == wrapper.conversionScore(Boolean.TYPE);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Object.class);
      assert ConversionScore.nomatch == wrapper
            .conversionScore(InvalidClass.class);
   }

   @Test
   public void testDateWrapper() throws Exception
   {
      DateWrapper wrapper = new DateWrapper();
      String value = "20061231123045150";
      wrapper.setElement(createElement("date", value));

      Calendar cal = Calendar.getInstance();
      cal.set(Calendar.YEAR, 2006);
      cal.set(Calendar.MONTH, Calendar.DECEMBER);
      cal.set(Calendar.DATE, 31);
      cal.set(Calendar.HOUR_OF_DAY, 12);
      cal.set(Calendar.MINUTE, 30);
      cal.set(Calendar.SECOND, 45);
      cal.set(Calendar.MILLISECOND, 150);

      assertEquals(cal.getTime(), wrapper.convert(Date.class));

      ByteArrayOutputStream out = new ByteArrayOutputStream();
      wrapper.marshal(out);

      byte[] expected = ("<date>" + value + "</date>").getBytes();
      assertEquals(expected, out.toByteArray());

      try
      {
         // this should throw an exception
         wrapper.convert(InvalidClass.class);
         assert false;
      }
      catch (ConversionException ex)
      {
      }

      try
      {
         // this should throw an exception
         wrapper.setElement(createElement("date", "foobar"));
         wrapper.convert(Date.class);
         assert false;
      }
      catch (ConversionException ex)
      {
      }

      // test conversionScore() method
      assert ConversionScore.exact == wrapper.conversionScore(Date.class);
      assert ConversionScore.exact == wrapper
            .conversionScore(java.sql.Date.class);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Object.class);
      assert ConversionScore.nomatch == wrapper
            .conversionScore(InvalidClass.class);
   }

   @Test
   public void testStringWrapper() throws Exception
   {
      String value = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
            + "!@#$%^&*()_+-=`~[]{}|;:\"',./<>?\\ ";
      StringWrapper wrapper = new StringWrapper();
      wrapper.setElement(createElement("str", value));

      assert value.equals(wrapper.convert(String.class));
      assert value
            .equals(((StringBuilder) wrapper.convert(StringBuilder.class))
                  .toString());
      assert value.equals(((StringBuffer) wrapper.convert(StringBuffer.class))
            .toString());

      ByteArrayOutputStream out = new ByteArrayOutputStream();
      wrapper.marshal(out);
      byte[] expected = ("<str>"
            + URLEncoder.encode(value, StringWrapper.DEFAULT_ENCODING) + "</str>")
            .replace("+", "%20").getBytes();

      assertEquals(expected, out.toByteArray());

      value = "123";
      wrapper.setElement(createElement("str", value));

      assert Integer.valueOf(value).equals(wrapper.convert(Integer.class));
      assert Integer.valueOf(value).equals(wrapper.convert(Integer.TYPE));
      assert Long.valueOf(value).equals(wrapper.convert(Long.class));
      assert Long.valueOf(value).equals(wrapper.convert(Long.TYPE));
      assert Short.valueOf(value).equals(wrapper.convert(Short.class));
      assert Short.valueOf(value).equals(wrapper.convert(Short.TYPE));
      assert Byte.valueOf(value).equals(wrapper.convert(Byte.class));
      assert Byte.valueOf(value).equals(wrapper.convert(Byte.TYPE));

      value = "123.4567";
      wrapper.setElement(createElement("str", value));

      assert Double.valueOf(value).equals(wrapper.convert(Double.class));
      assert Double.valueOf(value).equals(wrapper.convert(Double.TYPE));
      assert Float.valueOf(value).equals(wrapper.convert(Float.class));
      assert Float.valueOf(value).equals(wrapper.convert(Float.TYPE));

      wrapper.setElement(createElement("str", Boolean.toString(true)));
      assert (Boolean) wrapper.convert(Boolean.class);
      assert (Boolean) wrapper.convert(Boolean.TYPE);

      wrapper.setElement(createElement("str", Boolean.toString(false)));
      assert !(Boolean) wrapper.convert(Boolean.class);
      assert !(Boolean) wrapper.convert(Boolean.TYPE);

      try
      {
         // Attempt an invalid conversion
         wrapper.convert(Integer.class);
         assert false;
      }
      catch (ConversionException ex)
      {
      }

      value = "A";
      wrapper.setElement(createElement("str", value));

      assert Character.valueOf(value.charAt(0)).equals(
            wrapper.convert(Character.class));
      assert Character.valueOf(value.charAt(0)).equals(
            wrapper.convert(Character.TYPE));

      value = "green";
      wrapper.setElement(createElement("str", value));

      assert TestEnum.valueOf(value).equals(wrapper.convert(TestEnum.class));

      try
      {
         wrapper.setElement(createElement("str", "foo"));
         // Attempt an invalid conversion
         wrapper.convert(InvalidClass.class);
         assert false;
      }
      catch (ConversionException ex)
      {
      }

      // Test conversionScore() method
      wrapper = new StringWrapper();

      assert ConversionScore.exact == wrapper.conversionScore(String.class);
      assert ConversionScore.exact == wrapper
            .conversionScore(StringBuffer.class);
      assert ConversionScore.exact == wrapper
            .conversionScore(StringBuffer.class);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Integer.class);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Integer.TYPE);
      assert ConversionScore.compatible == wrapper.conversionScore(Long.class);
      assert ConversionScore.compatible == wrapper.conversionScore(Long.TYPE);
      assert ConversionScore.compatible == wrapper.conversionScore(Short.class);
      assert ConversionScore.compatible == wrapper.conversionScore(Short.TYPE);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Boolean.class);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Boolean.TYPE);
      assert ConversionScore.compatible == wrapper.conversionScore(Float.class);
      assert ConversionScore.compatible == wrapper.conversionScore(Float.TYPE);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Character.class);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Character.TYPE);
      assert ConversionScore.compatible == wrapper.conversionScore(Byte.class);
      assert ConversionScore.compatible == wrapper.conversionScore(Byte.TYPE);

      wrapper.setElement(createElement("str", "green"));
      assert ConversionScore.compatible == wrapper
            .conversionScore(TestEnum.class);
      wrapper.setElement(createElement("str", "foo"));
      assert ConversionScore.nomatch == wrapper.conversionScore(TestEnum.class);

      assert ConversionScore.nomatch == wrapper
            .conversionScore(InvalidClass.class);
   }

   @Test
   public void testNumberWrapper() throws Exception
   {
      String value = "123";

      NumberWrapper wrapper = new NumberWrapper();
      wrapper.setElement(createElement("number", value));

      assert new Short(value).equals(wrapper.convert(Short.class));
      assert wrapper.convert(Short.TYPE).equals(Short.parseShort(value));

      assert new Integer(value).equals(wrapper.convert(Integer.class));
      assert wrapper.convert(Integer.TYPE).equals(Integer.parseInt(value));

      assert new Long(value).equals(wrapper.convert(Long.class));
      assert wrapper.convert(Long.TYPE).equals(Long.parseLong(value));

      assert new Byte(value).equals(wrapper.convert(Byte.class));
      assert wrapper.convert(Byte.TYPE).equals(Byte.parseByte(value));

      assert value.equals(wrapper.convert(String.class));

      value = "123.456";
      wrapper.setElement(createElement("number", value));

      assert new Double(value).equals(wrapper.convert(Double.class));
      assert Double.valueOf(value).equals(wrapper.convert(Double.TYPE));

      assert new Float(value).equals(wrapper.convert(Float.class));
      assert Float.valueOf(value).equals(wrapper.convert(Float.TYPE));

      value = "";
      wrapper.setElement(createElement("number", value));

      assert null == wrapper.convert(Short.class);
      assert null == wrapper.convert(Integer.class);
      assert null == wrapper.convert(Long.class);
      assert null == wrapper.convert(Float.class);
      assert null == wrapper.convert(Double.class);
      assert null == wrapper.convert(Byte.class);

      try
      {
         // Attempt an invalid conversion
         wrapper.convert(InvalidClass.class);
         assert false;
      }
      catch (ConversionException ex)
      {
      }

      assert ConversionScore.exact == wrapper.conversionScore(Integer.class);
      assert ConversionScore.exact == wrapper.conversionScore(Integer.TYPE);

      assert ConversionScore.compatible == wrapper
            .conversionScore(String.class);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Object.class);

      assert ConversionScore.nomatch == wrapper
            .conversionScore(InvalidClass.class);
   }

   /**
    * Dummy method used in testBagWrapper()
    * 
    * @return List
    */
   public List<String> dummy()
   {
      return null;
   }

   public InvalidList<String> dummyInvalid()
   {
      return null;
   }

   /**
    * Used in testBagWrapper()
    */
   @SuppressWarnings("serial")
   private class InvalidList<E> extends ArrayList<E>
   {
      @SuppressWarnings("unused")
      public InvalidList()
      {
         throw new InstantiationError();
      }
   }

   @Test
   public void testBagWrapper() throws Exception
   {
      BagWrapper wrapper = new BagWrapper();
      wrapper.setCallContext(new CallContext());

      String[] values = new String[2];
      values[0] = "foo";
      values[1] = "bar";

      Element e = createElement("bag", null);
      e.addElement("element").addElement("str").addText(values[0]);
      e.addElement("element").addElement("str").addText(values[1]);
      wrapper.setElement(e);

      // String Array
      String[] converted = (String[]) wrapper.convert(String[].class);
      assert values.length == converted.length;
      assertEquals(values[0], converted[0]);
      assertEquals(values[1], converted[1]);

      // List
      List convertedList = (List) wrapper.convert(List.class);
      assert values.length == convertedList.size();
      assertEquals(values[0], convertedList.get(0));
      assertEquals(values[1], convertedList.get(1));

      // List<String> (Generic type)

      // Isn't there an easier way of getting a generic type than this??
      Type t = RemotingTest.class.getMethod("dummy").getGenericReturnType();

      List<String> stringList = (List<String>) wrapper.convert(t);
      assert values.length == stringList.size();
      assertEquals(values[0], stringList.get(0));
      assertEquals(values[1], stringList.get(1));

      // Set
      Set s = (Set) wrapper.convert(Set.class);
      assert values.length == s.size();
      assert s.contains(values[0]);
      assert s.contains(values[1]);

      // Queue
      Queue q = (Queue) wrapper.convert(Queue.class);
      assert values.length == q.size();
      assert q.contains(values[0]);
      assert q.contains(values[1]);

      // Concrete class
      ArrayList l = (ArrayList) wrapper.convert(ArrayList.class);
      assert values.length == l.size();
      assertEquals(values[0], l.get(0));
      assertEquals(values[1], l.get(1));

      try
      {
         // This should throw a ConversionException
         wrapper.convert(InvalidList.class);
         assert false;
      }
      catch (ConversionException ex)
      {
      }

      t = RemotingTest.class.getMethod("dummyInvalid").getGenericReturnType();
      try
      {
         // This should throw a ConversionException also
         wrapper.convert(t);
         assert false;
      }
      catch (ConversionException ex)
      {
      }

      int[] intValues = new int[2];
      intValues[0] = 44444;
      intValues[1] = 55555;

      e = createElement("bag", null);
      e.addElement("element").addElement("number").addText("" + intValues[0]);
      e.addElement("element").addElement("number").addText("" + intValues[1]);
      wrapper.setElement(e);

      // int Array
      int[] convertedInts = (int[]) wrapper.convert(int[].class);
      assert intValues.length == convertedInts.length;
      assertEquals(intValues[0], convertedInts[0]);
      assertEquals(intValues[1], convertedInts[1]);

      // Test marshal()

      byte[] expected = ("<bag><element><number>" + intValues[0]
            + "</number></element>" + "<element><number>" + intValues[1] + "</number></element></bag>")
            .getBytes();
      ByteArrayOutputStream out = new ByteArrayOutputStream();
      wrapper.marshal(out);
      assertEquals(expected, out.toByteArray());

      List intList = new ArrayList();
      intList.add(intValues[0]);
      intList.add(intValues[1]);
      wrapper.setValue(intList);
      out.reset();
      wrapper.marshal(out);
      assertEquals(expected, out.toByteArray());

      try
      {
         // This should throw a RuntimeException
         wrapper.setValue(new InvalidClass());
         wrapper.marshal(out);
         assert false;
      }
      catch (RuntimeException ex)
      {
      }

      // test conversionScore() method
      assert ConversionScore.compatible == wrapper
            .conversionScore(String[].class);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Object.class);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Collection.class);
      assert ConversionScore.nomatch == wrapper
            .conversionScore(InvalidClass.class);
   }

   @Test
   public void testBeanWrapper()
   {
      // BeanWrapper wrapper = new BeanWrapper();

      /** @todo Write tests for BeanWrapper */
   }

   /**
    * Used in testMapWrapper()
    */
   public Map<String, String> dummyMap()
   {
      return null;
   }

   /**
    * Used in testMapWrapper()
    */
   @SuppressWarnings("serial")
   private class InvalidMap extends HashMap
   {
      @SuppressWarnings("unused")
      public InvalidMap()
      {
         throw new InstantiationError();
      }
   }

   @Test
   public void testMapWrapper() throws Exception
   {
      MapWrapper wrapper = new MapWrapper();
      wrapper.setCallContext(new CallContext());

      // Construct a map with two elements, foo:aaaaa and bar:zzzzz
      Element e = DocumentFactory.getInstance().createElement("map");
      Element child = e.addElement("element");
      child.addElement("k").addElement("str").addText("foo");
      child.addElement("v").addElement("str").addText("aaaaa");
      child = e.addElement("element");
      child.addElement("k").addElement("str").addText("bar");
      child.addElement("v").addElement("str").addText("zzzzz");

      wrapper.setElement(e);

      // Conversion tests
      Map m = (Map) wrapper.convert(Map.class);
      assert m.containsKey("foo");
      assert m.containsKey("bar");
      assert "aaaaa".equals(m.get("foo"));
      assert "zzzzz".equals(m.get("bar"));

      m = (Map) wrapper.convert(HashMap.class);
      assert m.containsKey("foo");
      assert m.containsKey("bar");
      assert "aaaaa".equals(m.get("foo"));
      assert "zzzzz".equals(m.get("bar"));

      Type t = RemotingTest.class.getMethod("dummyMap").getGenericReturnType();
      m = (Map) wrapper.convert(t);
      assert m.containsKey("foo");
      assert m.containsKey("bar");
      assert "aaaaa".equals(m.get("foo"));
      assert "zzzzz".equals(m.get("bar"));

      try
      {
         // This should throw a ConversionException
         wrapper.convert(InvalidClass.class);
         assert false;
      }
      catch (ConversionException ex)
      {
      }

      try
      {
         // This should throw a ConversionException also
         wrapper.convert(InvalidMap.class);
         assert false;
      }
      catch (ConversionException ex)
      {
      }

      // ensure when we marshal/unmarshal the values in the map remain the same      
      ByteArrayOutputStream out = new ByteArrayOutputStream();
      wrapper.marshal(out);
      
      SAXReader xmlReader = new SAXReader();
      Document doc = xmlReader.read( new ByteArrayInputStream(out.toByteArray()) );     
      
      Element root = doc.getRootElement();      
      
      MapWrapper other = new MapWrapper();
      other.setCallContext(new CallContext());
      other.setElement(root);
      
      Map otherMap = (Map) other.convert(Map.class);
      for (Object key : otherMap.keySet())
      {
         assert otherMap.get(key).equals(m.get(key));
      }      

      // test conversionScore() method
      assert ConversionScore.exact == wrapper.conversionScore(Map.class);
      assert ConversionScore.exact == wrapper.conversionScore(HashMap.class);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Object.class);
      assert ConversionScore.nomatch == wrapper
            .conversionScore(InvalidClass.class);
   }

   @Test
   public void testNullWrapper() throws Exception
   {
      NullWrapper wrapper = new NullWrapper();
      assert wrapper.convert(null) == null;

      byte[] expected = "<null/>".getBytes();
      ByteArrayOutputStream out = new ByteArrayOutputStream();
      wrapper.marshal(out);
      assertEquals(expected, out.toByteArray());

      assert ConversionScore.compatible == wrapper.conversionScore(null);
      assert ConversionScore.compatible == wrapper
            .conversionScore(Object.class);
   }

   @Test
   public void testBaseWrapper()
   {
      BaseWrapper wrapper = new BaseWrapper()
      {
         public ConversionScore conversionScore(Class cls)
         {
            return ConversionScore.nomatch;
         }

         public void marshal(OutputStream out)
         {
         }

         public Object convert(Type type)
         {
            return null;
         }
      };

      Object value = new Object();
      wrapper.setValue(value);

      assert value.equals(wrapper.getValue());

      // For code-coverage completeness
      wrapper.unmarshal();
      wrapper.setCallContext(null);
      try
      {
         wrapper.serialize(null);
      }
      catch (IOException ex)
      {
      }
   }

   @Test
   public void testWrapperFactory()
   {
      try
      {
         // This should throw a RuntimeException
         WrapperFactory.getInstance().createWrapper("invalid");
         assert false;
      }
      catch (RuntimeException ex)
      {
      }

      assert WrapperFactory.getInstance().getWrapperForObject(null) instanceof NullWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(new HashMap()) instanceof MapWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(new String[2]) instanceof BagWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(new ArrayList()) instanceof BagWrapper;
      assert WrapperFactory.getInstance()
            .getWrapperForObject(new Boolean(true)) instanceof BooleanWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(true) instanceof BooleanWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(TestEnum.blue) instanceof StringWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(new Date()) instanceof DateWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(new Object()) instanceof BeanWrapper;

      // All the String types
      assert WrapperFactory.getInstance().getWrapperForObject("foo") instanceof StringWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(
            new StringBuffer("foo")) instanceof StringWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(
            new StringBuilder("foo")) instanceof StringWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(
            new Character('a')) instanceof StringWrapper;

      // All the number types
      assert WrapperFactory.getInstance().getWrapperForObject(111) instanceof NumberWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(111) instanceof NumberWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(111) instanceof NumberWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(123.456) instanceof NumberWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(123.456) instanceof NumberWrapper;
      assert WrapperFactory.getInstance().getWrapperForObject(111) instanceof NumberWrapper;

   }

   @Test
   public void testConversionScore()
   {
      // For code-coverage completeness
      assert 0 == ConversionScore.nomatch.getScore();
      assert 1 == ConversionScore.compatible.getScore();
      assert 2 == ConversionScore.exact.getScore();
      ConversionScore.valueOf("exact");
   }

   @Test
   public void testConstraints() throws Exception
   {
      // Initialize Seam
      MockServletContext servletContext = new MockServletContext();
      ServletLifecycle.beginApplication(servletContext);
      new Initialization(servletContext).create().init();

      try
      {
         Lifecycle.beginCall();

         // Create our object graph
         Widget result = new Widget();
         result.setValue("foo");
         result.setSecret("bar");

         ByteArrayOutputStream out = new ByteArrayOutputStream();
         
         // Constrain a single field of the result
         Call c = new Call(null, null, null);
         c.setConstraints(Arrays.asList(new String[] { "secret" }));
         c.setResult(result);
         MarshalUtils.marshalResult(c, out);

         SAXReader xmlReader = new SAXReader();
         Document doc = xmlReader.read(new StringReader(new String(out
               .toByteArray())));

         Widget widget = (Widget) ParserUtils.unmarshalResult(doc
               .getRootElement());

         // value field should equal "foo"
         assert "foo".equals(widget.getValue());

         // secret field should be null
         assert widget.getSecret() == null;

         // Now extend our object graph a little further
         result.setChild(new Widget());
         result.getChild().setValue("foo");
         result.getChild().setSecret("bar");

         // Reset our output stream so we can re-use it
         out.reset();

         // Now we're going to constrain result.child's secret field
         c.setConstraints(Arrays.asList(new String[] { "child.secret" }));
         MarshalUtils.marshalResult(c, out);

         doc = xmlReader.read(new StringReader(new String(out.toByteArray())));
         widget = (Widget) ParserUtils.unmarshalResult(doc.getRootElement());
         assert "foo".equals(widget.getValue());
         assert "bar".equals(widget.getSecret());
         assert "foo".equals(widget.getChild().getValue());
         assert widget.getChild().getSecret() == null;

         // Add a map to our result
         result.setWidgetMap(new HashMap<String, Widget>());
         Widget val = new Widget();
         val.setValue("foo");
         val.setSecret("bar");
         result.getWidgetMap().put("foo", val);

         // Reset our output stream again
         out.reset();

         // Constrain the "secret" field of the widgetMap map's values (sounds
         // confusing, I know...)
         c.setConstraints(Arrays.asList(new String[] { "widgetMap[value].secret" }));
         MarshalUtils.marshalResult(c, out);

         doc = xmlReader.read(new StringReader(new String(out.toByteArray())));
         widget = (Widget) ParserUtils.unmarshalResult(doc.getRootElement());
         val = widget.getWidgetMap().get("foo");
         assert val != null;
         assert "foo".equals(val.getValue());
         assert val.getSecret() == null;

         // Reset our output stream
         out.reset();

         // Add a list to our result
         result.setWidgetList(new ArrayList<Widget>());
         Widget item = new Widget();
         item.setValue("foo");
         item.setSecret("bar");
         result.getWidgetList().add(item);

         // Constraint the "secret" field of widgetList
         c.setConstraints(Arrays.asList(new String[] { "widgetList.secret" }));
         MarshalUtils.marshalResult(c, out);

         doc = xmlReader.read(new StringReader(new String(out.toByteArray())));
         widget = (Widget) ParserUtils.unmarshalResult(doc.getRootElement());
         item = widget.getWidgetList().get(0);
         assert item != null;
         assert "foo".equals(item.getValue());
         assert item.getSecret() == null;

         // Reset our output stream
         out.reset();

         // Now constrain all secrets
         c.setConstraints(Arrays.asList(new String[] { "[" + Widget.class.getName() + "].secret" }));
         MarshalUtils.marshalResult(c, out);

         doc = xmlReader.read(new StringReader(new String(out.toByteArray())));
         widget = (Widget) ParserUtils.unmarshalResult(doc.getRootElement());

         val = widget.getWidgetMap().get("foo");
         item = widget.getWidgetList().get(0);

         assert "foo".equals(widget.getValue());
         assert "foo".equals(widget.getChild().getValue());
         assert "foo".equals(val.getValue());
         assert "foo".equals(item.getValue());

         assert widget.getSecret() == null;
         assert widget.getChild().getSecret() == null;
         assert val.getSecret() == null;
         assert item.getSecret() == null;
      }
      finally
      {
         Lifecycle.endCall();
      }
   }

   class ProxyInterfaceGenerator extends InterfaceGenerator
   {
      @Override
      public String getFieldType(Type type)
      {
         return super.getFieldType(type);
      }
   }

   static class Dummy
   {
      enum TestEnum
      {
         foo, bar
      }

      public String getString()
      {
         return null;
      }

      public TestEnum getEnum()
      {
         return null;
      }

      public BigInteger getBigInteger()
      {
         return null;
      }

      public BigDecimal getBigDecimal()
      {
         return null;
      }

      public Boolean getBoolean()
      {
         return null;
      }

      public boolean getBool()
      {
         return false;
      }

      public Short getShort()
      {
         return null;
      }

      public short getSht()
      {
         return 0;
      }

      public Integer getInteger()
      {
         return null;
      }

      public int getInt()
      {
         return 0;
      }

      public Long getLong()
      {
         return null;
      }

      public long getLng()
      {
         return 0;
      }

      public Float getFloat()
      {
         return null;
      }

      public float getFlt()
      {
         return 0;
      }

      public Double getDouble()
      {
         return null;
      }

      public double getDbl()
      {
         return 0;
      }

      public Byte getByte()
      {
         return null;
      }

      public byte getByt()
      {
         return 0;
      }

      public Date getDate()
      {
         return null;
      }

      public int[] getIntArray()
      {
         return null;
      }

      public Map getMap()
      {
         return null;
      }

      public Collection getCollection()
      {
         return null;
      }

      public Map<String, String> getGenericMap()
      {
         return null;
      }

      public Collection<String> getGenericCollection()
      {
         return null;
      }
   }

   private Type getDummyReturnType(String methodName)
   {
      try
      {
         return Dummy.class.getMethod(methodName).getGenericReturnType();
      }
      catch (NoSuchMethodException ex)
      {
         return null;
      }
   }

   /**
    * Test that the correct remoting type is returned for various Java types
    */
   @Test
   public void testInterfaceGenerator()
   {
      ProxyInterfaceGenerator gen = new ProxyInterfaceGenerator();
      assert ("str".equals(gen.getFieldType(getDummyReturnType("getString"))));
      assert ("str".equals(gen.getFieldType(getDummyReturnType("getEnum"))));
      assert ("str".equals(gen
            .getFieldType(getDummyReturnType("getBigInteger"))));
      assert ("str".equals(gen
            .getFieldType(getDummyReturnType("getBigDecimal"))));
      assert ("bool".equals(gen.getFieldType(getDummyReturnType("getBoolean"))));
      assert ("bool".equals(gen.getFieldType(getDummyReturnType("getBool"))));
      assert ("number".equals(gen.getFieldType(getDummyReturnType("getShort"))));
      assert ("number".equals(gen.getFieldType(getDummyReturnType("getSht"))));
      assert ("number".equals(gen
            .getFieldType(getDummyReturnType("getInteger"))));
      assert ("number".equals(gen.getFieldType(getDummyReturnType("getInt"))));
      assert ("number".equals(gen.getFieldType(getDummyReturnType("getLong"))));
      assert ("number".equals(gen.getFieldType(getDummyReturnType("getLng"))));
      assert ("number".equals(gen.getFieldType(getDummyReturnType("getFloat"))));
      assert ("number".equals(gen.getFieldType(getDummyReturnType("getFlt"))));
      assert ("number"
            .equals(gen.getFieldType(getDummyReturnType("getDouble"))));
      assert ("number".equals(gen.getFieldType(getDummyReturnType("getDbl"))));
      assert ("number".equals(gen.getFieldType(getDummyReturnType("getByte"))));
      assert ("number".equals(gen.getFieldType(getDummyReturnType("getByt"))));
      assert ("date".equals(gen.getFieldType(getDummyReturnType("getDate"))));
      assert ("bag".equals(gen.getFieldType(getDummyReturnType("getIntArray"))));
      assert ("map".equals(gen.getFieldType(getDummyReturnType("getMap"))));
      assert ("bag".equals(gen
            .getFieldType(getDummyReturnType("getCollection"))));
      assert ("map".equals(gen
            .getFieldType(getDummyReturnType("getGenericMap"))));
      assert ("bag".equals(gen
            .getFieldType(getDummyReturnType("getGenericCollection"))));
   }
}