/*
    * Created on 30.04.2005 from Linke
    *
    */
   package test.crispy.util;
   
   import java.lang.reflect.Method;
   import java.math.BigDecimal;
   import java.math.BigInteger;
  import java.sql.Time;
  import java.sql.Timestamp;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.Hashtable;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Properties;
  import java.util.Vector;
  
  import junit.framework.TestCase;
  import net.sf.crispy.InvocationException;
  import net.sf.crispy.impl.ServiceManager;
  import net.sf.crispy.util.Converter;
  import net.sf.crispy.util.Invoker;
  import test.crispy.example.model.Adresse;
  import test.crispy.example.model.Car;
  import test.crispy.example.model.ClassWithNoParameterConstructor;
  import test.crispy.example.model.DataTransferObject;
  import test.crispy.example.model.InvalidClass;
  import test.crispy.example.model.Kunde;
  import test.crispy.example.model.Node;
  import test.crispy.example.model.NodeHashCode1;
  import test.crispy.example.model.NodeHashCode2;
  import test.crispy.example.model.NodeHashCode3;
  import test.crispy.example.model.Primitive;
  import test.crispy.example.model.ProblemNode;
  import test.crispy.example.model.SpecialTestClass;
  import test.crispy.example.model.Status;
  import test.crispy.example.model.SubProblemNode;
  import test.crispy.example.model.SubSubProblemNode;
  import test.crispy.example.service.Calculator;
  
  /**
   * @author Linke
   *
   */
  public class ConverterTest extends TestCase {
  	
  	public static final String DELIMITER = "~_-_~";
  	
  	public void testMakeSimple() throws Exception {
  		assertNull(new Converter().makeSimple(null));
  		assertEquals(new Converter().makeSimple(new Integer(5)), new Integer(5));
  		assertEquals(new Converter().makeSimple(new Double(5.4)), new Double(5.4));
  		assertEquals(new Converter().makeSimple(Boolean.TRUE), Boolean.TRUE);
  		assertEquals(new Converter().makeSimple(new String("string")), new String("string"));
  		Date lvDate = new Date();
  		assertEquals(new Converter().makeSimple(lvDate), lvDate);
  		Map lvMap = new Hashtable(2);
  		lvMap.put("String", "String");
  		lvMap.put(new Integer(1), new Integer(1));
  		assertEquals(new Converter().makeSimple(lvMap), lvMap);
  		Vector v = new Vector();
  		v.add("String");  
  		v.add(new Integer(5)); 
  		assertEquals(new Converter().makeSimple(v), v);
  	}
  		
  	public void testMakeSimpleConvert() throws Exception {
  		byte lvByte = 5;
  		short lvShort = 7; 
  		assertEquals(new Converter().makeSimple(new Byte(lvByte)), new Integer(5));
  		assertEquals(new Converter().makeSimple(new Long(6)), new Integer(6));
  		assertEquals(new Converter().makeSimple(new Short(lvShort)), new Integer(7));
  		assertEquals(new Converter().makeSimple(new Float(5.4)), new Double(5.4));
  		assertEquals(new Converter().makeSimple(new Character('A')), new String("A"));
  		assertEquals(new Converter().makeSimple(new BigDecimal(4.32)), new Double(4.32));
  		Date lvDate = new Date();
  		java.sql.Date lvDateSql = new java.sql.Date(lvDate.getTime());
  		assertEquals(new Converter().makeSimple(lvDateSql), lvDate);
  	}
  	
  	public void testMakeSimpleConverterWithVectorWithNullElement() throws Exception {
  		Vector v = new Vector();
  		v.add(null);
  		Object lvResult = new Converter().makeSimple(v);
  		assertNotNull(lvResult);
  		assertTrue(lvResult instanceof Vector);
  		Vector v2 = (Vector) lvResult;
  		assertEquals(v2.size(), 0);
  	}
  	
  	public void testMakeComplexWithNull() throws Exception {
  		Object lvResult = new Converter().makeComplex(null);
 		assertNull(lvResult);
 	}
 	
 	public void testMakeComplexWithObject() throws Exception {
 		Object lvResult = new Converter().makeComplex(new Object());
 		assertNull(lvResult);
 	}
 	
 	public void testMakeSimpleTimeConvert() throws Exception {
 		Time lvTime = new Time(new Date().getTime());
 		Object o = new Converter().makeComplex(new Converter().makeSimple(lvTime), Time.class);
 		assertEquals(lvTime, o);
 		Timestamp lvTimestamp = new Timestamp(new Date().getTime());
 		o = new Converter().makeComplex(new Converter().makeSimple(lvTimestamp), Timestamp.class);
 		assertEquals(lvTimestamp, o);
 	}
 	
 	public void testDate2Time() throws Exception {
 		Converter lvConverter = new Converter();
 		Date d = new Date();
 		Time time = (Time) lvConverter.makeComplex(d, Time.class);
 		assertNotNull(time);
 		assertEquals(d, time);
 		
 		Timestamp ts = new Timestamp(d.getTime());
 		Time time2 = (Time) lvConverter.makeComplex(ts, Time.class);
 		assertNotNull(time2);
 		assertEquals(d, time2);
 		
 		Long l = new Long(d.getTime());
 		Time time3 = (Time) lvConverter.makeComplex(l, Time.class);
 		assertNotNull(time3);
 		assertEquals(d, time3);
 		
 		try {
 			lvConverter.makeComplex(new String ("blabla"), Time.class);
 			fail("String: blabla is not a Time");
 		} catch (InvocationException e) {
 			assertTrue(true);
 		}
 	}
 	
 	public void testDate2Timestamp() throws Exception {
 		Converter lvConverter = new Converter();
 		Date d = new Date();
 		Timestamp ts = (Timestamp) lvConverter.makeComplex(d, Timestamp.class);
 		assertNotNull(ts);
 		assertEquals(d, ts);
 		
 		Time t = new Time(d.getTime());
 		Timestamp ts2 = (Timestamp) lvConverter.makeComplex(t, Timestamp.class);
 		assertNotNull(ts2);
 		assertEquals(d, ts2);
 
 		Long l = new Long(d.getTime());
 		Timestamp ts3 = (Timestamp) lvConverter.makeComplex(l, Timestamp.class);
 		assertNotNull(ts3);
 		assertEquals(d, ts3);		
 		
 		try {
 			lvConverter.makeComplex(new String ("blabla"), Timestamp.class);
 			fail("String: blabla is not a Timestamp");
 		} catch (InvocationException e) {
 			assertTrue(true);
 		}
 	}
 
 	
 	public void testMakeSimpleClassConvert() throws Exception {
 		Class lvTimeClass = Time.class;
 		Object o = new Converter().makeComplex(new Converter().makeSimple(lvTimeClass), Class.class);
 		assertEquals(lvTimeClass, o);
 	}
 
 	public void testMakeSimpleStringBufferConvert() throws Exception {
 		StringBuffer lvBuffer = new StringBuffer("Hallo");
 		Object o = new Converter().makeComplex(new Converter().makeSimple(lvBuffer), StringBuffer.class);
 		assertEquals(lvBuffer.toString(), o.toString());
 		assertEquals(lvBuffer.getClass(), o.getClass());
 	}
 	
 	public void testMakeSimpleBigConvert() throws Exception {
 		BigInteger lvBigInteger = new BigInteger("12345");
 		Object o = new Converter().makeComplex(new Converter().makeSimple(lvBigInteger), BigInteger.class);
 		assertEquals(lvBigInteger, o);
 		
 		BigDecimal lvBigDecimal = new BigDecimal("12.33");
 		o = new Converter().makeComplex(new Converter().makeSimple(lvBigDecimal), BigDecimal.class);
 		assertEquals(lvBigDecimal.doubleValue(), ((BigDecimal) o).doubleValue(), 3);
 	}
 	
 	
 	public void testMakeSimpleMap() throws Exception {
 		Kunde lvKunde = new Kunde();
 		lvKunde.setName("Schulz");
 		lvKunde.setVorname("Egon");
 		lvKunde.setGehalt(new BigDecimal(5467.23));
 		Hashtable lvConvertKunde = (Hashtable) new Converter().makeSimple(lvKunde);
 		
 		assertEquals(lvConvertKunde.get("gehalt"), new Double(5467.23));
 		assertEquals(lvConvertKunde.get("name"), "Schulz");
 		assertEquals(lvConvertKunde.get("vorname"), "Egon");
 		assertEquals(lvConvertKunde.get("class"), Kunde.class.getName());
 		assertEquals(new Vector(), lvConvertKunde.get("adressen"));
 	}
 	
 	public void testMakeSimpleMapWithIntegerKey() throws Exception {
 		Map lvMap = new HashMap();
 		lvMap.put(new Integer(1), new Integer(2));
 		Map lvResultMap = (Map) new Converter().makeSimple(lvMap);
 		Object lvKey = lvResultMap.keySet().iterator().next();
 		Object lvValue = lvResultMap.values().iterator().next();
 		assertEquals(lvKey.getClass(), Integer.class);
 		assertEquals(lvValue.getClass(), Integer.class);
 		assertEquals(lvKey, new Integer(1));
 		assertEquals(lvValue, new Integer(2));
 	}
 
 	public void testMakeSimpleMapWithKeyConverterLong2Integer() throws Exception {
 		Map lvMap = new HashMap();
 		lvMap.put(new Long(1), new Long(2));
 		Map lvResultMap = (Map) new Converter().makeSimple(lvMap);
 		Object lvKey = lvResultMap.keySet().iterator().next();
 		Object lvValue = lvResultMap.values().iterator().next();
 		assertEquals(lvKey.getClass(), Integer.class);
 		assertEquals(lvValue.getClass(), Integer.class);
 		assertEquals(lvKey, new Integer(1));
 		assertEquals(lvValue, new Integer(2));
 	}
 
 	public void testMakeSimpleAndComplexMapWithKeyConverterLong2Integer() throws Exception {
 		Map lvMap = new HashMap();
 		lvMap.put(new Long(1), new Long(2));
 		Converter lvConverter = new Converter();
 		lvConverter.setWithSimpleKeyMapper(true);
 		Object lvSimple = lvConverter.makeSimple(lvMap);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof Map);
 		Map lvMapAfter = (Map) lvComplex;
 		assertEquals(lvMapAfter.size(), 1);
 		assertEquals(lvMapAfter.keySet().iterator().next(), new Long(1));
 		assertEquals(lvMapAfter.values().iterator().next(), new Integer(2));
 	}
 
 	public void testMakeTwiceSimpleMapWithKeyConverterLong2Integer() throws Exception {
 		Map lvMap = new HashMap();
 		lvMap.put(new Long(1), new Long(2));
 		Converter lvConverter = new Converter();
 		lvConverter.setWithSimpleKeyMapper(true);
 		Object lvSimple = lvConverter.makeSimple(lvMap);
 		lvSimple = lvConverter.makeSimple(lvSimple);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof Map);
 		Map lvMapAfter = (Map) lvComplex;
 		assertEquals(lvMapAfter.size(), 1);
 		assertEquals(lvMapAfter.keySet().iterator().next(), new Long(1));
 		assertEquals(lvMapAfter.values().iterator().next(), new Integer(2));
 	}
 
 	public void testMakeSimpleAndComplexWithDifferentConverterAndThrownException() throws Exception {
 		Map lvMap = new HashMap();
 		lvMap.put(new Long(1), new Long(2));
 		Converter lvConverterSimple = new Converter();
 		Object lvSimple = lvConverterSimple.makeSimple(lvMap);
 		
 		Converter lvConverterComplex = new Converter();
 		lvConverterComplex.setWithSimpleKeyMapper(true);
 		try {
 			lvConverterComplex.makeComplex(lvSimple);
 			fail("Key must be a String");
 		} catch (Exception e) {
 			assertTrue(true);
 		}
 		
 	}
 
 	public void testMakeSimpleAndComplexWithDifferentConverterMapWithKeyConverterLong2Integer() throws Exception {
 		Map lvMap = new HashMap();
 		lvMap.put("1", new Long(2));
 		Converter lvConverterSimple = new Converter();
 		Object lvSimple = lvConverterSimple.makeSimple(lvMap);
 		
 		Converter lvConverterComplex = new Converter();
 		lvConverterComplex.setWithSimpleKeyMapper(true);
 		try {
 			lvConverterComplex.makeComplex(lvSimple);
 			fail("Make simple is without SimpleKeyMappe, makeComplex has a SimpleKeyMapper");
 		} catch (Exception e) {
 			assertTrue(true);
 		}
 	}
 	
 	public void testMakeSimpleAndComplexWithDifferentConverterMapWithKeyConverterLong2Integer2() throws Exception {
 		Map lvMap = new HashMap();
 		lvMap.put("1", new Long(2));
 		Converter lvConverterSimple = new Converter();
 		lvConverterSimple.setWithSimpleKeyMapper(true);
 		Object lvSimple = lvConverterSimple.makeSimple(lvMap);
 		
 		
 		Converter lvConverterComplex = new Converter();
 		Object lvComplex = lvConverterComplex.makeComplex(lvSimple);
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof Map);
 		Map lvMapAfter = (Map) lvComplex;
 		assertEquals(1, lvMapAfter.size());
 		assertEquals("1" + DELIMITER + "1", lvMapAfter.keySet().iterator().next());
 		assertEquals(new Integer(2), lvMapAfter.values().iterator().next());
 	}
 
 
 	public void testMakeSimpleAndComplexMapWithKeyConverterLong2Integer_2() throws Exception {
 		Map lvMap = new HashMap();
 		lvMap.put(new Long(3), new Long(4));
 		lvMap.put(new Long(1), new Long(2));
 		lvMap.put(new Long(-1), new Long(-2));
 		Converter lvConverter = new Converter();
 		lvConverter.setWithSimpleKeyMapper(true);
 		Object lvSimple = lvConverter.makeSimple(lvMap);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof Map);
 		Map lvMapAfter = (Map) lvComplex;
 		assertEquals(lvMapAfter.size(), 3);
 		Iterator it = lvMapAfter.keySet().iterator();
 		while (it.hasNext()) {
 			Object lvKey = it.next();
 			Integer lvValue = (Integer) lvMapAfter.get(lvKey);
 			Long lvValueBefore =(Long) lvMap.get(lvKey);
 			assertEquals(lvValueBefore.intValue(), lvValue.intValue());
 
 		}
 	}
 
 
 	public void testMakeSimpleMapWithKeyConverterBigDecimal2Double() throws Exception {
 		Map lvMap = new HashMap();
 		lvMap.put(new BigDecimal("4.32"), new BigDecimal(5.67));
 		Map lvResultMap = (Map) new Converter().makeSimple(lvMap);
 		Object lvKey = lvResultMap.keySet().iterator().next();
 		Object lvValue = lvResultMap.values().iterator().next();
 		assertEquals(lvKey.getClass(), Double.class);
 		assertEquals(lvValue.getClass(), Double.class);
 		assertEquals(lvKey, new Double(4.32));
 		assertEquals(lvValue, new Double(5.67));		
 	}
 
 	public void testMakeSimpleAndComplexMapWithKeyConverterBigDecimal2Double() throws Exception {
 		Map lvMap = new HashMap();
 		lvMap.put(new BigDecimal("4.32"), new BigDecimal("5.67"));
 		Converter lvConverter = new Converter();
 		lvConverter.setWithSimpleKeyMapper(true);
 		Object lvSimple = lvConverter.makeSimple(lvMap);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof Map);
 		Map lvMapAfter = (Map) lvComplex;
 		assertEquals(lvMapAfter.size(), 1);
 		assertEquals(lvMapAfter.keySet().iterator().next(), new BigDecimal("4.32"));
 		assertEquals(lvMapAfter.values().iterator().next(), new Double("5.67"));
 	}
 
 	public void testMakeSimpleVector() throws Exception {
 		Kunde lvKunde1 = new Kunde();
 		lvKunde1.setName("Schulz");
 		lvKunde1.setVorname("Egon");
 		Kunde lvKunde2 = new Kunde();
 		lvKunde2.setName("Schulz");
 		lvKunde2.setVorname("Egon");
 		List lvListKunde = new ArrayList(2);
 		lvListKunde.add(lvKunde1);
 		lvListKunde.add(lvKunde2);
 		Vector lvVecKunde = (Vector) new Converter().makeSimple(lvListKunde);
 		
 		Map lvKunde1Map = (Map) lvVecKunde.get(0);
 		assertEquals(lvKunde1.getName(), lvKunde1Map.get("name"));
 		assertEquals(lvKunde1.getVorname(), lvKunde1Map.get("vorname"));
 
 		Map lvKunde2Map = (Map) lvVecKunde.get(0);
 		assertEquals(lvKunde2.getName(), lvKunde2Map.get("name"));
 		assertEquals(lvKunde2.getVorname(), lvKunde2Map.get("vorname"));
 	}
 	
 	public void testMakeSimpleObjectWithCycle() throws Exception {
 		Kunde k = new Kunde ("Test");
 		Adresse a1 = new Adresse();
 		a1.setOrt("Magdeburg");
 		Adresse a2 = new Adresse();
 		a2.setOrt("Cottbus");		
 		k.getAdressen().add(a1);
 		k.getAdressen().add(a2);
 		a1.setKunde(k);
 
 		Object o = new Converter().makeSimple(k);
 		assertTrue(o instanceof Hashtable);
 		Map lvMap = (Map) o;
 		assertEquals(lvMap.get("name"), "Test");
 		Vector v = (Vector) lvMap.get("adressen");
 		assertTrue(v.size() == 2);
 		lvMap = (Map) v.get(0);
 		assertEquals(lvMap.get("ort"), "Magdeburg");
 		// ref from the Kunde
 		o = lvMap.get("kunde");
 		assertEquals(Converter.HASH_CODE_KEY+k.hashCode(), o);
 		lvMap = (Map) v.get(1);
 		assertEquals(lvMap.get("ort"), "Cottbus");
 	}
 
 	public void testMakeSimpleObjectWithCycle2() throws Exception {
 		Kunde k = new Kunde ("Test");
 		Adresse a1 = new Adresse();
 		a1.setOrt("Magdeburg");
 		Adresse a2 = new Adresse();
 		a2.setOrt("Cottbus");		
 		k.getAdressen().add(a1);
 		k.getAdressen().add(a2);
 		a2.setKunde(k);
 
 		Object o = new Converter().makeSimple(k);
 		assertTrue(o instanceof Hashtable);
 		Map lvMap = (Map) o;
 		assertEquals(lvMap.get("name"), "Test");
 		Vector v = (Vector) lvMap.get("adressen");
 		assertTrue(v.size() == 2);
 		lvMap = (Map) v.get(0);
 		assertEquals(lvMap.get("ort"), "Magdeburg");
 		lvMap = (Map) v.get(1);
 		assertEquals(lvMap.get("ort"), "Cottbus");
 		// ref from the Kunde
 		o = lvMap.get("kunde");
 		assertEquals(Converter.HASH_CODE_KEY+k.hashCode(), o);
 	}
 
 	public void testMakeSimpleObjectWithCycleInMap() throws Exception {
 		Node n1 = new Node ("1");
 		Node n2 = new Node ("2");
 		Node n3 = new Node ("3");
 		Node na = new Node ("a");
 		Node nb = new Node ("b");
 
 		n1.getChildrenMap().put("2", n2);
 		n1.getChildrenMap().put("3", n3);
 		n1.getChildrenMap().put("a", na);
 		n1.getChildrenMap().put("b", nb);
 
 		n2.getChildrenMap().put("3", n3);
 		n3.getChildrenMap().put("1", n1);
 
 		Object o = new Converter().makeSimple(n1);
 		Map lvMap1 = (Map) o;
 		assertEquals(lvMap1.get("name"), "1");
 		Map lvMap1children = (Map) lvMap1.get("childrenMap");
 		assertEquals(((Map) lvMap1children.get("2")).get("name"), "2");
 		assertEquals(((Map) lvMap1children.get("3")).get("name"), "3");
 		assertEquals(((Map) lvMap1children.get("a")).get("name"), "a");
 		assertEquals(((Map) lvMap1children.get("b")).get("name"), "b");
 		Map lvMap2children = (Map) ((Map) lvMap1children.get("2")).get("childrenMap");
 		String lvHashCode3 = (String) ((Map) lvMap1children.get("3")).get(Converter.HASH_CODE_KEY);
 		assertEquals(Converter.extractHashCode(lvMap2children.get("3")), lvHashCode3);
 		
 		Node n1After = (Node) new Converter().makeComplex(o);
 		assertTrue(n1After.getChildrenMap().size() == 4);
 		assertEquals(((Node) n1After.getChildrenMap().get("a")).getName(), "a");
 		assertEquals(((Node) n1After.getChildrenMap().get("b")).getName(), "b");
 		
 		Node n3After = (Node) n1After.getChildrenMap().get("3");
 		assertEquals(n3After.getChildrenMap().get("1"), n1After);
 		
 		Node n2After = (Node)  n1After.getChildrenMap().get("2");
 		assertEquals(n2After.getChildrenMap().get("3"), n3After);
 	}
 
 		
 	public void testMakeSimpleObjectWithCycleInVector() throws Exception {
 		Adresse a1 = new Adresse();
 		a1.setOrt("Magdeburg");
 		Adresse a2 = new Adresse();
 		a2.setOrt("Cottbus");		
 		a1.getAdressen().add(a2);
 		a2.getAdressen().add(a1);
 
 		Object o = new Converter().makeSimple(a1);
 		assertTrue(o instanceof Hashtable);
 		Map lvMap = (Map) o;
 		assertEquals(lvMap.get("ort"), "Magdeburg");
 		Vector v = (Vector) lvMap.get("adressen");
 		assertTrue(v.size() == 1);
 		lvMap = (Map) v.get(0);
 		assertEquals(lvMap.get("ort"), "Cottbus");
 		v = (Vector) lvMap.get("adressen");
 		assertTrue(v.size() == 1);
 		o = v.get(0);
 		// Ref from a1
 		assertEquals(Converter.HASH_CODE_KEY+a1.hashCode(), o);
 	}
 	
 	public void testMakeNodeTree() throws Exception {
 		Node lvNode1 = Node.createExampleTree();
 		Object o = new Converter().makeSimple(lvNode1);
 		assertTrue(o instanceof Hashtable);
 		Map lvMap = (Map) o;
 		assertEquals(lvMap.get("name"), "1");
 		Vector v = (Vector) lvMap.get("children");
 		assertEquals(v.size(), 3);
 		
 		Map lvMapNodea = (Map) v.get(0);
 		assertEquals(lvMapNodea.get("name"), "a");
 
 		Map lvMapNode2 = (Map) v.get(1);
 		assertEquals(lvMapNode2.get("name"), "2");
 		Vector v2 = (Vector) lvMapNode2.get("children");
 		assertEquals(v2.size(), 2);
 		o = v2.get(0);
 		// Ref from a1
 		Node lvNodea = (Node) lvNode1.getChildren().get(0);
 		assertEquals(Converter.HASH_CODE_KEY + lvNodea.hashCode(), o);
 
 		
 		Map lvMapNode3 = (Map) v.get(2);
 		assertEquals(lvMapNode3.get("name"), "3");
 		Vector v3 = (Vector) lvMapNode3.get("children");
 		assertEquals(v3.size(), 2);
 		o = v3.get(0);
 		// Ref from a1
 		assertEquals(Converter.HASH_CODE_KEY + lvNodea.hashCode(), o);
 	}
 	
 	
 	public void testMakeSimpleAndComplexNodeTree() throws Exception {
 		Node n1 = new Node ("1");
 		Node n2 = new Node ("2");
 		Node n3 = new Node ("3");
 		n1.setNode(n2);
 		n2.setNode(n3);
 		n3.setNode(n1);
 
 		Object o = new Converter().makeSimple(n1);
 		o = new Converter().makeComplex(o);
 		Node n11 = (Node) o;
 		assertEquals(n1.getName(), n11.getName());
 		assertEquals(n2.getName(), n11.getNode().getName());
 		assertEquals(n3.getName(), n11.getNode().getNode().getName());
 		assertEquals(n11.getNode().getNode().getNode(), n11);		
 	}
 
 	public void testMakeSimpleAndComplexNodeTree2() throws Exception {
 		Node n1 = new Node ("1");
 		Node n2 = new Node ("2");
 		Node n3 = new Node ("3");
 		Node na = new Node ("a");
 		Node nb = new Node ("b");
 		n1.setNode(n2);
 		n2.setNode(n3);
 		n3.setNode(n1);
 		n1.getChildren().add(na);
 		n1.getChildren().add(nb);
 		n2.getChildren().add(na);
 		n3.getChildren().add(nb);
 		
 		Object o = new Converter().makeSimple(n1);
 		o = new Converter().makeComplex(o);
 		Node n11 = (Node) o;
 		Node n1a = (Node) n11.getChildren().get(0);
 		Node n1b = ((Node) n11.getChildren().get(1));
 			
 		assertEquals(n1.getName(), n11.getName());
 		assertEquals(n1a.getName(), na.getName());
 		assertEquals(n1b.getName(), nb.getName());
 		
 		assertEquals(n2.getName(), n11.getNode().getName());
 		assertEquals(n1a, n11.getNode().getChildren().get(0));
 		
 		assertEquals(n3.getName(), n11.getNode().getNode().getName());
 		assertEquals(n11.getNode().getNode().getNode(), n11);		
 		assertEquals(n1b, n11.getNode().getNode().getChildren().get(0));
 	}
 	
 	public void testMakeSimpleAndComplexTree() throws Exception {
 		Node lvNodeRoot1 = Node.createExampleTree();
 		Object o = new Converter().makeSimple(lvNodeRoot1);
 		
 		Node lvNode1 = (Node) new Converter().makeComplex(o);
 		Node lvNodea = (Node) lvNode1.getChildren().get(0);
 		assertEquals(lvNodea.getName(), "a");
 		Node lvNode2 = (Node) lvNode1.getChildren().get(1);
 		assertEquals(lvNode2.getName(), "2");
 		Node lvNode3 = (Node) lvNode1.getChildren().get(2);
 		assertEquals(lvNode3.getName(), "3");
 		
 		Node lvNodea2 = (Node) lvNode2.getChildren().get(0);
 		assertEquals(lvNodea.getName(), lvNodea2.getName());
 		assertEquals(lvNodea, lvNodea2);
 		Node lvNodeb2 = (Node) lvNode2.getChildren().get(1);
 		assertEquals("b", lvNodeb2.getName());
 		
 		Node lvNodea3 = (Node) lvNode3.getChildren().get(0);
 		assertEquals(lvNodea.getName(), lvNodea3.getName());
 		assertEquals(lvNodea, lvNodea3);
 		Node lvNodeb3 = (Node) lvNode3.getChildren().get(1);
 		assertEquals("b", lvNodeb3.getName());
 		assertEquals(lvNodeb2, lvNodeb3);
 	}
 	
 	public void testMakeSimpleAndComplexTreeMap() throws Exception {
 		Node n1 = new Node ("1");
 		Node n2 = new Node ("2");
 		Node n3 = new Node ("3");
 		Node na = new Node ("a");
 		Node nb = new Node ("b");
 
 		n1.getChildrenMap().put("2", n2);
 		n1.getChildrenMap().put("3", n3);
 		n1.getChildrenMap().put("a", na);
 		n1.getChildrenMap().put("b", nb);
 		n2.getChildrenMap().put("3", n3);
 		n3.getChildrenMap().put("1", n1);
 
 		Object o = new Converter().makeSimple(n1);		
 		Node n1After = (Node) new Converter().makeComplex(o);
 		assertEquals(n1After.getName(), n1.getName());
 		assertEquals(n1After.getChildrenMap().size(), n1.getChildrenMap().size());
 		Node n2After = (Node) n1After.getChildrenMap().get("2");
 		assertEquals(n2After.getName(), n2.getName());
 		Node n3After = (Node) n1After.getChildrenMap().get("3");
 		assertEquals(n3After.getName(), n3.getName());
 		Node naAfter = (Node) n1.getChildrenMap().get("a");
 		assertEquals(naAfter.getName(), na.getName());
 		Node nbAfter = (Node) n1.getChildrenMap().get("b");
 		assertEquals(nbAfter.getName(), nb.getName());
 		
 		assertEquals(n3After, n2After.getChildrenMap().get("3"));
 		assertEquals(n1After.getName(), ((Node) n3After.getChildrenMap().get("1")).getName());
 		assertEquals(n1After, n3After.getChildrenMap().get("1"));
 	}
 	
 	public void testBiDirectionalNodeRelation() throws Exception {
 		Node n1 = new Node("Node1");
 		Node n2 = new Node("Node2");
 		Node n3 = new Node("Node3");
 		
 		n1.getChildrenMap().put(n2.getName(), n2);
 		n1.getChildrenMap().put(n3.getName(), n3);
 		n2.setNode(n1);
 		n3.setNode(n1);
 		Vector v = new Vector();
 		v.add(n2);
 		v.add(n3);
 
 		Converter lvConverter = new Converter();
 		Object o = lvConverter.makeSimple(v);
 		o = lvConverter.makeComplex(o);
 		
 		assertTrue(o instanceof Vector);
 		v = (Vector) o;
 		assertEquals(v.size(), 2);
 		Node n22 = (Node) v.get(0);
 		Node n33 = (Node) v.get(1);
 		assertEquals(n22.getName(), n2.getName());
 		assertEquals(n33.getName(), n3.getName());
 		Node n11 = n22.getNode();
 		assertEquals(n11.getName(), n33.getNode().getName());
 		assertEquals(n22.getNode(), n33.getNode());
 		assertEquals(n22.getNode(), n11);
 		assertEquals(n33.getNode(), n11);
 		assertEquals(n11.getChildrenMap().get(n22.getName()), n22);
 		assertEquals(n11.getChildrenMap().get(n33.getName()), n33);
 	}
 	
 	
 	public void testMakeComplex() throws Exception {
 		Map lvKundeMap = new Hashtable();
 		lvKundeMap.put("name", "Meier");
 		lvKundeMap.put("vorname", "Nadine");
 		lvKundeMap.put("gehalt", new Double(1234.5));
 		lvKundeMap.put("class", Kunde.class.getName());
 
 		Kunde lvKunde = (Kunde) new Converter().makeComplex(lvKundeMap);
 		
 		assertEquals(lvKunde.getName(), lvKundeMap.get("name"));
 		assertEquals(lvKunde.getVorname(), lvKundeMap.get("vorname"));
 		assertEquals(lvKunde.getGehalt().toString(), lvKundeMap.get("gehalt").toString());	
 	}
 	
 	public void testMakeComplexMap() throws Exception {
 		Map lvKundeMap = new Hashtable();
 		lvKundeMap.put("name", "Meier");
 		lvKundeMap.put("vorname", "Nadine");
 		lvKundeMap.put("gehalt", new Double(1234.5));
 
 		Map lvComplexMap = (Map) new Converter().makeComplex(lvKundeMap);
 		assertTrue(lvComplexMap instanceof Hashtable);
 		assertTrue(lvComplexMap.size() == 3);
 		assertTrue(lvComplexMap.get("name").equals("Meier"));
 	}
 
 	public void testMakeComplexList() throws Exception {
 		List lvList = new ArrayList();
 		lvList.add(new Integer(5));
 		lvList.add("abc");
 		
 		List lvComplexList = (List) new Converter().makeComplex(lvList);
 		assertTrue(lvComplexList instanceof Vector);
 		assertTrue(lvComplexList.size() == 2);
 		assertTrue(lvComplexList.get(0).equals(new Integer(5)));
 	}
 
 	public void testMakeComplexConverterWithVectorWithNullElement() throws Exception {
 		Vector v = new Vector();
 		v.add(null);
 		Object lvResult = new Converter().makeComplex(v);
 		assertNotNull(lvResult);
 		assertTrue(lvResult instanceof Vector);
 		Vector v2 = (Vector) lvResult;
 		assertEquals(v2.size(), 0);
 	}
 
 	public void testMakeComplexSimpleDatatypes() throws Exception {
 		Date lvDate = new Date();
 		Object lvResult = new Converter().makeComplex(lvDate);
 		assertNotNull(lvResult);
 		assertTrue(lvResult instanceof Date);
 
 		java.sql.Date lvDateSql = new java.sql.Date(lvDate.getTime());
 		lvResult = new Converter().makeComplex(lvDateSql);
 		assertNotNull(lvResult);
 		assertTrue(lvResult instanceof java.sql.Date);
 
 		lvResult = new Converter().makeComplex(new Byte((byte) 5));
 		assertNotNull(lvResult);
 		assertTrue(lvResult instanceof Byte);
 		assertEquals(lvResult, new Byte((byte) 5));
 		
 		lvResult = new Converter().makeComplex(new Short((short) 7));
 		assertNotNull(lvResult);
 		assertTrue(lvResult instanceof Short);
 		assertEquals(lvResult, new Short((short) 7));
 
 		lvResult = new Converter().makeComplex(new Float(5.4));
 		assertNotNull(lvResult);
 		assertTrue(lvResult instanceof Float);
 		assertEquals(lvResult, new Float(5.4));
 		
 		lvResult = new Converter().makeComplex(new Character('c'));
 		assertNotNull(lvResult);
 		assertTrue(lvResult instanceof Character);
 		assertEquals(lvResult, new Character('c'));
 		
 	}
 
 	public void testConvertPrimitiveDatatype() throws Exception {
 		Primitive lvPrimitive = new Primitive();
 		lvPrimitive.setBooleanValue(true);
 		short s = 1; 
 		lvPrimitive.setShortValue(s);
 		byte b = 2;
 		lvPrimitive.setByteValue(b);
 		lvPrimitive.setIntValue(3);
 		lvPrimitive.setLongValue(4);
 		lvPrimitive.setDoubleValue(4.3);
 		lvPrimitive.setFloatValue(5.8f);
 		lvPrimitive.setCharValue('C');
 		
 		Map lvPrimitiveMap = (Map) new Converter().makeSimple(lvPrimitive);
 		Primitive lvPrimitivePost = (Primitive) new Converter().makeComplex(lvPrimitiveMap);
 		
 		assertEquals(lvPrimitive.getBooleanValue(), lvPrimitivePost.getBooleanValue());
 		assertEquals(lvPrimitive.getByteValue(), lvPrimitivePost.getByteValue());
 		assertEquals(lvPrimitive.getShortValue(), lvPrimitivePost.getShortValue());
 		assertEquals(lvPrimitive.getIntValue(), lvPrimitivePost.getIntValue());
 		assertEquals(lvPrimitive.getLongValue(), lvPrimitivePost.getLongValue());
 		assertEquals(lvPrimitive.getDoubleValue(), lvPrimitivePost.getDoubleValue(), 0);
 		assertEquals(lvPrimitive.getFloatValue(), lvPrimitivePost.getFloatValue(), 0);
 		assertEquals(lvPrimitive.getCharValue(), lvPrimitivePost.getCharValue());
 	}
 	
 	public void testConvertSet() throws Exception {
 		String lvSetString = "SET";
 		String lvNodeName = "SET-NODE";
 		Node lvNode = new Node (lvNodeName);
 		lvNode.getSets().add(lvSetString);
 		Converter c = new Converter();
 		Object simple = c.makeSimple(lvNode);
 		Node lvNode2 = (Node) c.makeComplex(simple);
 		assertEquals(lvNode2.getName(), lvNodeName);
 		assertEquals(lvNode2.getSets().size(), 1);
 		assertEquals(lvNode2.getSets().iterator().next(), lvSetString);
 	}
 	
 	public void testConvertString2Value() throws Exception {
 		Object o = Converter.convertString2Value("true", boolean.class);
 		assertTrue(o.getClass().getName().equals(Boolean.class.getName()));
 		o = Converter.convertString2Value("true", Boolean.class);
 		assertTrue(o.getClass().getName().equals(Boolean.class.getName()));
 		o = Converter.convertString2Value("1", short.class);
 		assertTrue(o.getClass().getName().equals(Short.class.getName()));
 		o = Converter.convertString2Value("3", byte.class);
 		assertTrue(o.getClass().getName().equals(Byte.class.getName()));
 		o = Converter.convertString2Value("3", int.class);
 		assertTrue(o.getClass().getName().equals(Integer.class.getName()));
 		o = Converter.convertString2Value("3", long.class);
 		assertTrue(o.getClass().getName().equals(Long.class.getName()));
 		o = Converter.convertString2Value("3.1", double.class);
 		assertTrue(o.getClass().getName().equals(Double.class.getName()));
 		o = Converter.convertString2Value("3.4", float.class);
 		assertTrue(o.getClass().getName().equals(Float.class.getName()));
 		o = Converter.convertString2Value("a", char.class);
 		assertTrue(o.getClass().getName().equals(Character.class.getName()));
 		o = Converter.convertString2Value("abc", String.class);
 		assertTrue(o.getClass().getName().equals(String.class.getName()));
 		if (Locale.getDefault().equals(Locale.GERMANY)) {
 			o = Converter.convertString2Value("28.12.2005", Date.class);
 			assertTrue(o.getClass().getName().equals(Date.class.getName()));
 		}		
 		o = Converter.convertString2Value("BlaBla", BigInteger.class);
 		assertNull(o);
 	}
 
 	public void testConvertString2Value2() throws Exception {
 		Object o = Converter.convertString2Value("true", Boolean.class.getName());
 		assertTrue(o.getClass().getName().equals(Boolean.class.getName()));
 		assertTrue( ((Boolean)o).booleanValue() == Boolean.TRUE.booleanValue());
 
 		o = Converter.convertString2Value("true", boolean.class.getName());
 		assertTrue(o.getClass().getName().equals(Boolean.class.getName()));
 		assertTrue( ((Boolean)o).booleanValue() == Boolean.TRUE.booleanValue());
 		
 		o = Converter.convertString2Value("3", Integer.class.getName());
 		assertTrue(o.getClass().getName().equals(Integer.class.getName()));
 		assertTrue( ((Integer)o).intValue() == 3);
 		
 		o = Converter.convertString2Value("5", int.class.getName());
 		assertTrue(o.getClass().getName().equals(Integer.class.getName()));
 		assertTrue( ((Integer)o).intValue() == 5);
 		
 		o = Converter.convertString2Value("2", byte.class.getName());
 		assertTrue(o.getClass().getName().equals(Byte.class.getName()));
 		assertTrue( ((Byte)o).byteValue() == 2);
 
 		o = Converter.convertString2Value("4", short.class.getName());
 		assertTrue(o.getClass().getName().equals(Short.class.getName()));
 		assertTrue( ((Short)o).shortValue() == 4);
 
 		o = Converter.convertString2Value("6", long.class.getName());
 		assertTrue(o.getClass().getName().equals(Long.class.getName()));
 		assertTrue( ((Long)o).longValue() == 6);
 
 		o = Converter.convertString2Value("5.4", double.class.getName());
 		assertTrue(o.getClass().getName().equals(Double.class.getName()));
 		assertTrue( ((Double)o).doubleValue() == 5.4);
 		
 		o = Converter.convertString2Value("c", char.class.getName());
 		assertTrue(o.getClass().getName().equals(Character.class.getName()));
 		assertTrue( ((Character)o).charValue() == 'c');
 
 		o = Converter.convertString2Value("5.4", float.class.getName());
 		assertTrue(o.getClass().getName().equals(Float.class.getName()));
 		assertEquals( ((Float)o).floatValue(), 5.4, 0.01);
 		
 		o = Converter.convertString2Value(null , float.class);
 		assertNull(o);
 
 		o = Converter.convertString2Value(new Date().toString(), Date.class.getName());
 		assertTrue(o.getClass().getName().equals(Date.class.getName()));
 
 		o = Converter.convertString2Value(new Kunde().toString(), Kunde.class.getName());
 		assertTrue(o.getClass().getName().equals(Kunde.class.getName()));
 
 	}
 		
 	public void testConvertStringParams2MethodParams() throws Exception {
 		Vector lvParam = new Vector();
 		lvParam.add(new Integer(5));
 		lvParam.add(new Integer(3));
 		Method lvMethod = Invoker.findMethod(Calculator.class, "add", lvParam);
 		
 		Vector lvParam2 = new Vector();
 		lvParam2.add(new String("5"));
 		lvParam2.add(new String("3"));
 		Object o[] = Converter.convertStringParams2MethodParams(lvMethod, lvParam2);
 		assertTrue(o.length == lvParam2.size());
 		assertTrue(o[0].getClass().getName().equals(Integer.class.getName()));
 		assertTrue(o[1].getClass().getName().equals(Integer.class.getName()));
 		assertTrue(o[0].equals(new Integer(5)));
 		assertTrue(o[1].equals(new Integer(3)));
 		
 		try {
 			Converter.convertStringParams2MethodParams(null, lvParam2);
 			fail("convertStringParams2MethodParams with method = null must throw a Exception");
 		} catch (Exception e) {
 			assertTrue(true);
 		}
 
 		try {
 			lvParam2.remove(0);
 			Converter.convertStringParams2MethodParams(lvMethod, lvParam2);
 			fail("convertStringParams2MethodParams with must throw a Exception with false parameter size");
 		} catch (Exception e) {
 			assertTrue(true);
 		}
 
 	}
 
 	public void testString2CurrentDate() throws Exception {
 		Date d = new Date();
 		Date d2 = Converter.string2Date(d.toString());
 		assertEquals(d2.toString(), d.toString());
 		
 		try {
 			d2 = Converter.string2Date(null);
 			fail("Date euqals null is illegal argument");
 		} catch (Exception e) {
 			assertTrue(true);
 		}
 
 		try {
 			d2 = Converter.string2Date("False Date");
 			fail("Date euqals String: 'False Date' is illegal argument");
 		} catch (Exception e) {
 			assertTrue(true); 
 		}
 
 		
 	}
 	
 	/** Tue Mar 01 20:23:55 CET 2005 - 1109705105302 */
 	public void testString2DateCET() throws Exception {
 		Date d = new Date(1109705105302l);
 		Date d2 = Converter.string2Date(d.toString());
 		assertEquals(d2.toString(), d.toString());
 	}
 
 	/** Sat Oct 01 20:25:34 CEST 2005 -- 1128191134214 */
 	public void testString2DateCEST() throws Exception {
 		Date d = new Date(1128191134214l);
 		Date d2 = Converter.string2Date(d.toString());
 		assertEquals(d2.toString(), d.toString());
 	}
 
 	public void testClassWithoutPackage() throws Exception {
 		String lvString = Converter.getClassWithoutPackage(ServiceManager.class.getName(), true);
 		assertEquals(lvString, "servicemanager");
 		lvString = Converter.getClassWithoutPackage(ServiceManager.class.getName(), false);
 		assertEquals(lvString, "ServiceManager");
 		lvString = Converter.getClassWithoutPackage(null, false);
 		assertNull(lvString);
 	}
 	
 	public void testConvertArray() throws Exception {
 		String s[] = new String[] {"a","b","c"};
 		Object o = new Converter().makeSimple(s);
 		assertTrue(o instanceof Vector);
 		Vector v = (Vector) o;
 		assertTrue(v.size() == 3);
 		o = new Converter().makeComplex(o, String[].class);
 		assertTrue(o.getClass().isArray());
 		String array[] = (String[]) o;
 		assertEquals(array.getClass().getComponentType(), String.class);
 		assertTrue(array.length == 3);
 		assertEquals(array[0], "a");
 		assertEquals(array[1], "b");
 		assertEquals(array[2], "c");
 	}
 	
 	public void testArrayType_Array() throws Exception {
 		Class lvType = Converter.getArrayType(null);
 		assertEquals(lvType, Object.class);
 		lvType = Converter.getArrayType(new String[0]);
 		assertEquals(lvType, String.class);
 		lvType = Converter.getArrayType(new String[] {"a", "b"});
 		assertEquals(lvType, String.class);
 		lvType = Converter.getArrayType(new Long[] {new Long(1), new Long(3)});
 		assertEquals(lvType, Long.class);
 		lvType = Converter.getArrayType(new Object[] {new Long(1), new Long(3)});
 		assertEquals(lvType, Long.class);
 		lvType = Converter.getArrayType(new Object[] {new Long(1), "c"});
 		assertEquals(lvType, Object.class);		
 		
 		Vector v = new Vector();
 		lvType = Converter.getArrayType(v);
 		assertEquals(lvType, Object.class);
 		
 		v.add(new String());
 		lvType = Converter.getArrayType(v);
 		assertEquals(lvType, String.class);
 		
 		Map lvMap = new HashMap();
 		lvType = Converter.getArrayType(lvMap);
 		assertEquals(lvType, Object.class);
 	}
 	
 	public void testArrayType_Collection() throws Exception {
 		Vector v = new Vector();
 		v.add("a");
 		v.add("b");
 		Class lvType = Converter.getArrayType(v);
 		assertEquals(lvType, String.class);			
 		v = new Vector();
 		v.add(new Long (1));
 		v.add(new Long (2));
 		lvType = Converter.getArrayType(v);
 		assertEquals(lvType, Long.class);			
 		v = new Vector();
 		v.add(new Long (1));
 		v.add("b");
 		lvType = Converter.getArrayType(v);
 		assertEquals(lvType, Object.class);
 	}
 	
 	public void testExtractHashCode() throws Exception {
 		String lvHashCodeString = null;
 		assertNull(Converter.extractHashCode(lvHashCodeString));
 		int lvHashCode = 24306761;
 		lvHashCodeString = Converter.HASH_CODE_KEY + lvHashCode;
 		assertNotNull(Converter.extractHashCode(lvHashCodeString));
 		assertEquals(Converter.extractHashCode(lvHashCodeString), Integer.toString(lvHashCode));
 		
 		lvHashCodeString = "dummy" + lvHashCode;
 		assertNull(Converter.extractHashCode(lvHashCodeString));
 	}
 	
 	public void testConvertWithComplexMapKeyNotValid() throws Exception {
 		try {
 			Node n1 = new Node();
 			Node n2 = new Node();
 			n1.getChildrenMap().put(n2, n2);
 			Converter lvConverter = new Converter();
 			lvConverter.makeSimple(n1);
 			fail("Convert must throw Exception by complex Map-Key.");
 		} catch (Exception e) {
 			assertTrue(true);
 		}
 	}
 	
 	public void testConvertObjectWithSameHashCode() throws Exception {
 		SpecialTestClass c1 = new SpecialTestClass("Name1");
 		SpecialTestClass c2 = new SpecialTestClass("Name2");
 		SpecialTestClass c3 = new SpecialTestClass("Name3");
 		c1.getChilds().put(c2.getName(), c2);
 		c1.getChilds().put(c3.getName(), c3);
 		Converter lvConverter = new Converter();
 		Object o = lvConverter.makeSimple(c1);
 		SpecialTestClass c11 = (SpecialTestClass) lvConverter.makeComplex(o);
 		assertEquals(c1.getName(), c11.getName());
 		assertEquals(c1.getChilds().size(), c11.getChilds().size());
 		assertEquals(c2.getName(), ((SpecialTestClass) c11.getChilds().get(c2.getName())).getName());
 		assertEquals(c3.getName(), ((SpecialTestClass) c11.getChilds().get(c3.getName())).getName());
 	}
 	
 	public void testConvertObjectWithSameHashCodeWithCycle() throws Exception {
 		SpecialTestClass c1 = new SpecialTestClass("Name1");
 		SpecialTestClass c2 = new SpecialTestClass("Name2");
 		SpecialTestClass c3 = new SpecialTestClass("Name3");
 		c1.getChilds().put(c2.getName(), c2);
 		c2.getChilds().put(c3.getName(), c3);
 		c3.getChilds().put(c2.getName(), c2);
 		
 		Converter lvConverter = new Converter();
 		Object o = lvConverter.makeSimple(c1);
 		SpecialTestClass c11 = (SpecialTestClass) lvConverter.makeComplex(o);
 		assertEquals(c1.getName(), c11.getName());
 		assertEquals(c1.getChilds().size(), c11.getChilds().size());
 		SpecialTestClass c22 = (SpecialTestClass) c11.getChilds().get(c2.getName());
 		SpecialTestClass c33 = (SpecialTestClass) c22.getChilds().get(c3.getName());
 		assertEquals(c2.getName(), c22.getName());
 		assertEquals(c3.getName(), c33.getName());
 		assertEquals(c22.getChilds().get(c3.getName()), c33);
 	}
 	
 	public void testIsValideEdge() throws Exception {
 		boolean isValideEdge = Converter.isValideEdge(null);
 		assertFalse(isValideEdge);
 		
 		isValideEdge = Converter.isValideEdge(new String("STRING"));
 		assertFalse(isValideEdge);
 	}
 	
 	public void testConvertClassString2Object() throws Exception {
 		Object lvResult = Converter.convertClassString2Object(null);
 		assertNull(lvResult);
 		
 		lvResult = Converter.convertClassString2Object(int.class.getName());
 		assertEquals(lvResult, new Integer(0));
 
 		lvResult = Converter.convertClassString2Object(short.class.getName());
 		assertEquals(lvResult, new Short((short) 0));
 		
 		lvResult = Converter.convertClassString2Object(byte.class.getName());
 		assertEquals(lvResult, new Byte((byte) 0));
 		
 		lvResult = Converter.convertClassString2Object(long.class.getName());
 		assertEquals(lvResult, new Long(0));
 		
 		lvResult = Converter.convertClassString2Object(double.class.getName());
 		assertEquals(lvResult, new Double(0));
 		
 		lvResult = Converter.convertClassString2Object(float.class.getName());
 		assertEquals(lvResult, new Float(0));
 		
 		lvResult = Converter.convertClassString2Object(char.class.getName());
 		assertEquals(lvResult, new Character(' '));
 		
 		lvResult = Converter.convertClassString2Object(boolean.class.getName());
 		assertEquals(lvResult, Boolean.TRUE);
 		
 		lvResult = Converter.convertClassString2Object("[Ljava/lang/String;");
 		assertNotNull(lvResult);
 		assertTrue(lvResult instanceof String[]);
 		assertEquals(((String[])lvResult).length, 0);
 
 		lvResult = Converter.convertClassString2Object("[Ljava/lang/String_ERROR;");
 		assertNull(lvResult);
 		
 		lvResult = Converter.convertClassString2Object(new String[0].toString());
 		assertNull(lvResult);
 		
 		lvResult = Converter.convertClassString2Object(Long.class.getName());
 		assertEquals(lvResult, new Long(0));
 
 		lvResult = Converter.convertClassString2Object(BigInteger.class.getName());
 		assertEquals(lvResult, new BigInteger("0"));
 		
 		lvResult = Converter.convertClassString2Object(Date.class.getName());
 		assertTrue(lvResult instanceof Date);
 		
 		lvResult = Converter.convertClassString2Object(Float.class.getName());
 		assertEquals(lvResult, new Float(0));
 		
 		lvResult = Converter.convertClassString2Object(BigDecimal.class.getName());
 		assertEquals(lvResult, new BigDecimal("0"));
 
 		lvResult = Converter.convertClassString2Object(Kunde.class.getName());
 		assertTrue(lvResult instanceof Kunde);
 		
 		lvResult = Converter.convertClassString2Object(Timestamp.class.getName());
 		assertEquals(lvResult, new Timestamp(0));
 		
 		Character lvCharacter = (Character) Converter.convertClassString2Object(Character.class.getName());
 		assertEquals(new Character(' '), lvCharacter);
 		Boolean lvBoolean = (Boolean) Converter.convertClassString2Object(Boolean.class.getName());
 		assertEquals(Boolean.TRUE, lvBoolean);
 	}
 	
 	
 	public void testByEqualsHashCode() throws Exception {
 		NodeHashCode1 n11 = new NodeHashCode1("n11", 4);
 		NodeHashCode1 n12 = new NodeHashCode1("n12", 1);
 		NodeHashCode2 n21 = new NodeHashCode2("n21", 1);
 		NodeHashCode2 n22 = new NodeHashCode2("n22", 2);
 		n11.getChilds().add(n21);
 		n11.getChilds().add(n22);
 		
 		n12.getChilds().add(n21);
 		n12.getChilds().add(n22);
 		
 		List liste = new ArrayList();
 		liste.add(n11);
 		liste.add(n12);
 		liste.add(n21);
 		liste.add(n22);
 
 		Converter converter = new Converter(0);
 		Object o = converter.makeSimple(liste);
 		liste = (List) converter.makeComplex(o);
 		
 		assertNotNull(liste);
 		assertEquals(liste.size(), 4);
 		
 		NodeHashCode1 n1After = (NodeHashCode1) liste.get(0);
 		assertEquals( n1After.getName(), "n11");
 		assertEquals( ((NodeHashCode2) n1After.getChilds().get(0)).getName(), "n21");
 		assertEquals( ((NodeHashCode2) n1After.getChilds().get(1)).getName(), "n22");
 
 		NodeHashCode1 n2After = (NodeHashCode1) liste.get(1);
 		assertEquals( n2After.getName(), "n12");
 		assertEquals( ((NodeHashCode2) n2After.getChilds().get(0)).getName(), "n21");
 		assertEquals( ((NodeHashCode2) n2After.getChilds().get(1)).getName(), "n22");
 		
 		assertEquals( ((NodeHashCode2) liste.get(2)).getName(), "n21");
 		assertEquals( ((NodeHashCode2) liste.get(3)).getName(), "n22");
 	}
 
 	public void testByEqualsHashCode2() throws Exception {
 		NodeHashCode1 n11 = new NodeHashCode1("n11", 2);
 		NodeHashCode1 n12 = new NodeHashCode1("n12", 1);
 		NodeHashCode2 n21 = new NodeHashCode2("n21", 1);
 		NodeHashCode2 n22 = new NodeHashCode2("n22", 2);
 		n11.getChilds().add(n21);
 		n11.getChilds().add(n22);
 		
 		n12.getChilds().add(n21);
 		n12.getChilds().add(n22);
 		
 		List liste = new ArrayList();
 		liste.add(n11);
 		liste.add(n12);
 		liste.add(n21);
 		liste.add(n22);
 
 		Converter converter = new Converter(0);
 		Object o = converter.makeSimple(liste);
 		liste = (List) converter.makeComplex(o);
 		
 		assertNotNull(liste);
 		assertEquals(liste.size(), 4);
 		
 		NodeHashCode1 n1After = (NodeHashCode1) liste.get(0);
 		assertEquals( n1After.getName(), "n11");
 		assertEquals( ((NodeHashCode2) n1After.getChilds().get(0)).getName(), "n21");
 		assertEquals( ((NodeHashCode2) n1After.getChilds().get(1)).getName(), "n22");
 
 		NodeHashCode1 n2After = (NodeHashCode1) liste.get(1);
 		assertEquals( n2After.getName(), "n12");
 		assertEquals( ((NodeHashCode2) n2After.getChilds().get(0)).getName(), "n21");
 		assertEquals( ((NodeHashCode2) n2After.getChilds().get(1)).getName(), "n22");
 		
 		assertEquals( ((NodeHashCode2) liste.get(2)).getName(), "n21");
 		assertEquals( ((NodeHashCode2) liste.get(3)).getName(), "n22");
 	}
 
 	public void testByEqualsHashCode3() throws Exception {
 		NodeHashCode1 n11 = new NodeHashCode1("n11", 4);
 		NodeHashCode1 n12 = new NodeHashCode1("n12", 1);
 		NodeHashCode2 n21 = new NodeHashCode2("n21", 1);
 		n11.getChilds().add(n21);
 		n12.getChilds().add(n21);
 		
 		List liste = new ArrayList();
 		liste.add(n11);
 		liste.add(n12);
 		liste.add(n21);
 
 		Converter converter = new Converter(1);
 		Object o = converter.makeSimple(liste);
 		liste = (List) converter.makeComplex(o);
 
 		assertNotNull(liste);
 		assertEquals(liste.size(), 3);
 
 		NodeHashCode1 n1After = (NodeHashCode1) liste.get(0);
 		assertEquals( n1After.getName(), "n11");
 		assertEquals( ((NodeHashCode2) n1After.getChilds().get(0)).getName(), "n21");
 
 		NodeHashCode1 n2After = (NodeHashCode1) liste.get(1);
 		assertEquals( n2After.getName(), "n12");
 		assertEquals( ((NodeHashCode2) n2After.getChilds().get(0)).getName(), "n21");
 
 		assertEquals( ((NodeHashCode2) liste.get(2)).getName(), "n21");
 	}
 	
 	
 	public void testConvertArrayWithNullElement() throws Exception {
 		String s[] = new String[] {"a", null, "b","c"};
 		Object o = new Converter().makeSimple(s);
 		assertTrue(o instanceof Vector);
 		Vector v = (Vector) o;
 		assertTrue(v.size() == 3);
 		o = new Converter().makeComplex(o, String[].class);
 		assertTrue(o.getClass().isArray());
 		String array[] = (String[]) o;
 		assertEquals(array.getClass().getComponentType(), String.class);
 		assertTrue(array.length == 3);
 		assertEquals(array[0], "a");
 		assertEquals(array[1], "b");
 		assertEquals(array[2], "c");		
 	}
 	
 	public void testConvertMapWithNullElement() throws Exception {
 		Map lvMap = new HashMap(2);
 		lvMap.put("String", "String");
 		lvMap.put("null", null);
 		Object result = new Converter().makeSimple(lvMap);
 		assertTrue(result instanceof Map);
 		Map lvMapAfter = (Map) result;
 		assertEquals(lvMapAfter.size(), 1);
 	}
 	
 //	public void testInvokePrivateSetMethod() throws Exception {
 //		Method lvMethod = Invoker.findMethod(Node.class, "setId");
 //		assertNull(lvMethod);
 //		Node n = new Node();
 //		n = (Node) Converter.invokePrivateSetMethod(n, "id", new Long (5));
 //		assertEquals(n.getId(), new Long(5));
 //		
 //		n = new Node();
 //		n = (Node) Converter.invokePrivateSetMethod(n, "id_BAD", new Long (5));
 //		assertEquals(n.getId(), new Node().getId());
 //		
 //		n = new Node();
 //		n = (Node) Converter.invokePrivateSetMethod(n, "id", "Bad_Parameter_Typ");
 //		assertEquals(n.getId(), new Node().getId());
 //		
 //		n = new Node();
 //		n = (Node) Converter.invokePrivateSetMethod(n, "id", null);
 //		assertEquals(n.getId(), new Node().getId());
 //		
 //		n = (Node) Converter.invokePrivateSetMethod(null, "id", null);
 //		assertNull(n);		
 //
 //		n = (Node) Converter.invokePrivateSetMethod(null, null, null);
 //		assertNull(n);		
 //	}
 
 	public void testConverterWithInvokePrivateSetMethod() throws Exception {
 		Node n = new Node(new Long (97));
 		n.setName("Node-JUnit");
 		Converter c = new Converter();
 		Object o = c.makeSimple(n);
 		Node nAfter = (Node) c.makeComplex(o);
 		assertEquals(n.getId(), nAfter.getId());
 		assertEquals(nAfter.getName(), n.getName());
 	}
 
 	public void testConvertByteArray() throws Exception {
 		byte b [] = new byte[2];
 		assertEquals(b[0], 0);
 		assertEquals(b[1], 0);
 		byte bAfter[] = new byte[] {5, 6};
 		assertFalse(bAfter[0] == 0);
 		assertFalse(bAfter[1] == 0);
 		
 		Converter c = new Converter();
 		byte bAfterConvert[] = (byte[]) c.makeSimple(bAfter);
 		assertEquals(bAfter[0], bAfterConvert[0]);
 		assertEquals(bAfter[1], bAfterConvert[1]);
 		
 		byte bAfterConvert2[] = (byte[]) c.makeComplex(bAfterConvert);
 		assertEquals(bAfterConvert[0], bAfterConvert2[0]);
 		assertEquals(bAfterConvert[1], bAfterConvert2[1]);
 	}
 	
 	public void testConvertMakeCompleyWithInValidMap() throws Exception {
 		Map map = new HashMap();
 		map.put("class", "i.am.a.not.valid.Clazz");
 		Converter c = new Converter();
 		try {
 			c.makeComplex(map);
 			fail("Exception by converter.makeComplex is an Error");
 		} catch (Exception e) {
 			assertTrue(true);
 		}
 	}
 	
 	public void testClassWithNoParameterConstructor() throws Exception {
 		Map map = new HashMap();
 		map.put("class", ClassWithNoParameterConstructor.class.getName());
 		Converter c = new Converter();
 		try {
 			c.makeComplex(map);
 			fail("Exception by converter.makeComplex is an Error");
 		} catch (Exception e) {
 			assertTrue(true);
 		}
 
 	}
 	
 	public void testMakeSimpleNull() throws Exception {
 		Converter lvConverter = new Converter(null);
 		Object o = lvConverter.makeSimple(null);
 		assertNull(o);
 	}
 
 	public void testMakeSimpleNullValue() throws Exception {
 		String lvNullValue = "!!!NullValue!!!";
 		Converter lvConverter = new Converter(lvNullValue);
 		Object o = lvConverter.makeSimple(null);
 		assertNotNull(o);
 		assertEquals(o, lvNullValue);
 	}
 
 	public void testMakeSimpleComplexNullValue() throws Exception {
 		String lvNullValue = "---Null-Value--";
 		Kunde lvKunde = new Kunde("Name");
 		lvKunde.setVorname(null);
 		Converter lvConverter = new Converter(lvNullValue);
 		Object o = lvConverter.makeSimple(lvKunde);
 		assertNotNull(o);
 		Map lvMap = (Map) o;
 		assertEquals(lvMap.get("vorname"), null);
 		assertEquals(lvMap.get("gehalt"), null);
 	}
 
 	public void testMakeComplexNull() throws Exception {
 		Converter lvConverter = new Converter(null);
 		Object o = lvConverter.makeComplex(null);
 		assertNull(o);
 	}
 
 	public void testMakeComplexNullValue() throws Exception {
 		String lvNullValue = "!!!NullValue!!!";
 		Converter lvConverter = new Converter(lvNullValue);
 		Object o = lvConverter.makeComplex(lvNullValue);
 		assertNull(o);
 	}
 
 	public void testMakeComplexWithComplexObjectAndNullValue() throws Exception {
 		String lvNullValue = "---Null-Value--";
 		Kunde lvKunde = new Kunde("Name");
 		lvKunde.setVorname(null);
 		Converter lvConverter = new Converter(lvNullValue);
 		Object o = lvConverter.makeSimple(lvKunde);
 		assertNotNull(o);
 		Object oAfter = lvConverter.makeComplex(o);
 		assertNotNull(oAfter);
 		Kunde kAfter = (Kunde) oAfter;
 		assertEquals(kAfter.getName(), "Name");
 		assertNull(kAfter.getVorname());
 		assertNull(kAfter.getGehalt());
 	}
 
 	public void testAllGetterMethod() throws Exception {
 		Map lvGetterMap = Converter.getAllGetterAndSetterMethod(ProblemNode.class, Converter.GET_METHOD);
 		assertEquals(7, lvGetterMap.size());
 		assertNotNull(lvGetterMap.get("class"));
 		assertNotNull(lvGetterMap.get("id"));
 		
 		lvGetterMap = Converter.getAllGetterAndSetterMethod(SubProblemNode.class, Converter.GET_METHOD);
 		assertEquals(8, lvGetterMap.size());
 		assertNotNull(lvGetterMap.get("name2"));
 		
 		lvGetterMap = Converter.getAllGetterAndSetterMethod(SubSubProblemNode.class, Converter.GET_METHOD);
 		assertEquals(14, lvGetterMap.size());
 		assertNotNull(lvGetterMap.get("date"));
 		assertNotNull(lvGetterMap.get("privateDate"));
 
 	}
 	
 	public void testAllSetterMethod() throws Exception {
 		Map lvSetterMap = Converter.getAllGetterAndSetterMethod(ProblemNode.class, Converter.SET_METHOD);
 		assertEquals(5, lvSetterMap.size());
 		assertNull(lvSetterMap.get("class"));
 		assertNotNull(lvSetterMap.get("id"));
 		
 		lvSetterMap = Converter.getAllGetterAndSetterMethod(SubProblemNode.class, Converter.SET_METHOD);
 		assertEquals(6, lvSetterMap.size());
 		assertNotNull(lvSetterMap.get("name2"));
 
 		lvSetterMap = Converter.getAllGetterAndSetterMethod(SubSubProblemNode.class, Converter.SET_METHOD);
 		assertEquals(12, lvSetterMap.size());
 		assertNotNull(lvSetterMap.get("date"));
 		assertNotNull(lvSetterMap.get("privateDate"));
 	}
 
 	public void testAllNotEqualsGetterAndSetterAndRemoveThisProperties() throws Exception {
 		Map lvGetterMap = Converter.getAllGetterAndSetterMethod(ProblemNode.class, Converter.GET_METHOD);
 		lvGetterMap.remove("class");
 		Map lvSetterMap = Converter.getAllGetterAndSetterMethod(ProblemNode.class, Converter.SET_METHOD);
 		assertTrue(lvGetterMap.size() > lvSetterMap.size());
 		Map lvNewGetterMap = Converter.getAllNotEqualsGetterAndSetterAndRemoveThisProperties(lvGetterMap, lvSetterMap);
 		assertTrue(lvNewGetterMap.size() == lvSetterMap.size());
 	}
 	
 	public void testAllGetterAndSetterMethodInvalideMethodTyp() throws Exception {
 		Map lvMap = Converter.getAllGetterAndSetterMethod(ProblemNode.class, -99);
 		assertNotNull(lvMap);
 		assertEquals(0, lvMap.size());
 	}
 	public void testNullValue() throws Exception {
 		String lvNullValue = "MyTestNullValue";
 		assertEquals(lvNullValue, new Converter(lvNullValue).getNullValue());
 		
 	}
 	
 	public void testInvalideSetGetPropertyName() throws Exception {
 		Converter lvConverter = new Converter();
 		try {
 			lvConverter.makeSimple(new InvalidClass());
 			fail("Must thrown Exception by invalid property-name!");
 		} catch (Exception e) {
 			assertTrue(true);
 		}
 	}
 	
 	/** Resolve Bug: 1488645 */
 	public void testTimeByDateProperty() throws Exception {
 		SubSubProblemNode lvNode = new SubSubProblemNode();
 		Date lvDate = new Date();
 		Time lvTime = new Time(lvDate.getTime());
 		lvNode.setDate(lvTime);
 
 		Timestamp lvTimestamp = new Timestamp(lvDate.getTime());
 		lvNode.setDate2(lvTimestamp);
 		
 		Converter lvConverter = new Converter();
 		Object lvSimple = lvConverter.makeSimple(lvNode);
 		SubSubProblemNode lvNodeAfter = (SubSubProblemNode) lvConverter.makeComplex(lvSimple);
 		
 		assertEquals(lvDate, lvNodeAfter.getDate());
 		assertEquals(lvDate, lvNodeAfter.getDate2());
 	}
 	
 	public void testListWithDoubleInstanceAndNullValue() throws Exception {
 		Converter lvConverter = new Converter();
 		List l = new Vector();
 		Kunde k = new Kunde("Junit-Test-Kunde");
 		Object lvSimple = lvConverter.makeSimple(k);
 		
 		l.add(lvSimple);
 		l.add(null);
 		l.add(lvSimple);
 		
 		Object lvComplex = lvConverter.makeComplex(l);
 		
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof List);
 		// without null value
 		assertEquals(2, ((List) lvComplex).size());
 	}
 
 	public void testListWithDoubleInstanceAndNullValue2() throws Exception {
 		Converter lvConverter = new Converter();
 		List l = new Vector();
 		Kunde k = new Kunde("Junit-Test-Kunde");
 		k.setNullList(new ArrayList());
 		Object lvSimple = lvConverter.makeSimple(k);
 		
 		l.add(lvSimple);
 		l.add(null);
 		l.add(lvSimple);
 		
 		Object lvComplex = lvConverter.makeComplex(l);
 		
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof List);
 		// without null value
 		assertEquals(2, ((List) lvComplex).size());
 		Kunde kAfter0 = (Kunde) ((List) lvComplex).get(0);
 		assertEquals("Junit-Test-Kunde", kAfter0.getName());
 		assertNotNull(kAfter0.getNullList());
 		assertEquals(0, kAfter0.getNullList().size());
 	}
 
 	public void testCreateDefaultValueForPrimitiveClass() throws Exception {
 		Object lvResult = Converter.createDefaultValueForPrimitiveClass(boolean.class);
 		assertEquals(Boolean.FALSE, lvResult);
 
 		lvResult = Converter.createDefaultValueForPrimitiveClass(short.class);
 		assertEquals(new Short((short) 0), lvResult);		
 
 		lvResult = Converter.createDefaultValueForPrimitiveClass(byte.class);
 		assertEquals(new Byte((byte) 0), lvResult);		
 
 		lvResult = Converter.createDefaultValueForPrimitiveClass(int.class);
 		assertEquals(new Integer(0), lvResult);
 		
 		lvResult = Converter.createDefaultValueForPrimitiveClass(long.class);
 		assertEquals(new Long(0), lvResult);
 		
 		lvResult = Converter.createDefaultValueForPrimitiveClass(double.class);
 		assertEquals(new Double(0), lvResult);
 		
 		lvResult = Converter.createDefaultValueForPrimitiveClass(float.class);
 		assertEquals(new Float(0), lvResult);
 		
 		lvResult = Converter.createDefaultValueForPrimitiveClass(char.class);
 		assertEquals(new Character(' '), lvResult);
 		
 		lvResult = Converter.createDefaultValueForPrimitiveClass(Class.class);
 		assertNull(lvResult);		
 	}
 	
 	public void testMapInArrayByMakeComplex() throws Exception {
 		Converter lvConverter = new Converter();
 		Map lvPrimitiveMap = (Map) lvConverter.makeSimple(Primitive.createPrimitiveExample());
 		assertNotNull(lvPrimitiveMap);
 		Integer lvIntValue = (Integer) lvPrimitiveMap.get("intValue");
 		assertEquals(3, lvIntValue.intValue());
 		
 		Object lvPrimitiveArray[] = (Object[]) lvConverter.makeComplex(new Object [] { lvPrimitiveMap });
 		assertEquals(1, lvPrimitiveArray.length);
 		assertEquals(Primitive.createPrimitiveExample(), lvPrimitiveArray[0]);
 	}
 	
 	public void testSimpleStringMap() throws Exception {
 		Converter lvConverter = new Converter();
 		lvConverter.setWithSimpleKeyMapper(true);
 		
 		Map lvMap = new Hashtable();
 		lvMap.put("1", "1");
 		lvMap.put("5", "5");
 		lvMap.put("3", "3");
 		lvMap.put("A", "A");
 		lvMap.put("1", "1");
 		
 		Object lvSimple = lvConverter.makeSimple(lvMap);
 		assertTrue(lvSimple instanceof Map);
 		assertEquals(4, ((Map) lvSimple).size());
 		
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertTrue(lvComplex instanceof Map);
 		Map lvMapAfter = (Map) lvComplex;
 		assertEquals(4, ((Map) lvComplex).size());
 		assertEquals("1", lvMapAfter.get("1"));
 		assertEquals("5", lvMapAfter.get("5"));
 		assertEquals("A", lvMapAfter.get("A"));
 		assertEquals("3", lvMapAfter.get("3"));
 	}
 	
 	public void testConvertObjectWithEqualsAndHashCodeValue() throws Exception {
 		ProblemNode n = new ProblemNode("abc", new Long(3));		
 		n.setAspecialTestClass(new SpecialTestClass("AU1"));
 		n.setVspecialTestClass(new SpecialTestClass("AU1"));
 		
 		Kunde k1 = new Kunde("k1");
 		k1.setAktuellerStatus(new Status("AU1"));
 		k1.setVorgaengerStatus(new Status("AU1"));
 		n.getSets().add(k1);
 		
 		Converter c = new Converter();
 		Object o = c.makeSimple(n);
 		ProblemNode nAfter = (ProblemNode) c.makeComplex(o);
 		assertNotNull(nAfter);
 		assertEquals(nAfter.getName(), "abc");
 		assertEquals(new SpecialTestClass("AU1"), nAfter.getAspecialTestClass());
 		assertEquals(new SpecialTestClass("AU1"), nAfter.getVspecialTestClass());
 		assertSame(nAfter.getAspecialTestClass(), nAfter.getVspecialTestClass());
 
 		assertEquals(1, nAfter.getSets().size());
 		Kunde kAfter = (Kunde) nAfter.getSets().iterator().next();
 		assertEquals("k1", kAfter.getName());
 		assertEquals(new Status("AU1"), kAfter.getAktuellerStatus());
 		assertEquals(new Status("AU1"), kAfter.getVorgaengerStatus());
 		assertSame(kAfter.getAktuellerStatus(), kAfter.getVorgaengerStatus());
 	}
 	
 	public void testTwoMethodWithTheSameDateValue() throws Exception {
 		Kunde k1 = new Kunde("k1");
 		Date lvDate = new Date();
 		k1.setDate(lvDate);
 		k1.setDate2(lvDate);
 		
 		Converter c = new Converter();
 		Object o = c.makeSimple(k1);
 		Kunde kAfter = (Kunde) c.makeComplex(o);
 		assertEquals(lvDate, kAfter.getDate());
 		assertEquals(lvDate, kAfter.getDate2());
 	}
 	
 	public void testTheFirstLetterByGetAndSetIs() throws Exception {
 		Kunde k1 = new Kunde("k1");
 		Date lvDate = new Date();
 		k1.setdate3(lvDate);
 
 		Converter c = new Converter();
 		Object o = c.makeSimple(k1);
 		Kunde kAfter = (Kunde) c.makeComplex(o);
 		assertEquals(lvDate, kAfter.getdate3());
 	}
 	
 	public void testEmptyLists() throws Exception {
 		Kunde k1 = new Kunde("k1");
 		
 		Converter c = new Converter();
 		Object o = c.makeSimple(k1);
 		Kunde kAfter = (Kunde) c.makeComplex(o);
 
 		assertNotNull(kAfter);
 		assertEquals("k1", kAfter.getName());
 		assertNotNull(kAfter.getCars());
 		assertNotNull(kAfter.getAdressen());
 		assertEquals(0, kAfter.getCars().size());
 		assertEquals(0, kAfter.getAdressen().size());
 	}
 	
 	public void testEqualsEmptyLists() throws Exception {
 		Kunde k1 = new Kunde("k1");
 		
 		Converter c = new Converter();
 		Object o = c.makeSimple(k1);
 		Kunde kAfter = (Kunde) c.makeComplex(o);
 
 		assertNotNull(kAfter);
 		assertNotNull(kAfter.getCollection());
 		assertNotNull(kAfter.getAdressen());
 		assertEquals(0, kAfter.getCollection().size());
 		assertEquals(0, kAfter.getAdressen().size());
 	}
 	
 	public void testEqualsNullLists() throws Exception {
 		Kunde k1 = new Kunde("k1");
 		
 		Converter c = new Converter();
 		Object o = c.makeSimple(k1);
 		Kunde kAfter = (Kunde) c.makeComplex(o);
 
 		assertNotNull(kAfter);
 		assertNull(kAfter.getNullList());
 		
 		assertNotNull(kAfter.getAdressen());
 		assertEquals(0, kAfter.getAdressen().size());
 	}
 	
 
 	public void testEqualsEmptySetsWith() throws Exception {
 		Kunde k1 = new Kunde("k1");
 		
 		Converter c = new Converter();
 		Object o = c.makeSimple(k1);
 		Kunde kAfter = (Kunde) c.makeComplex(o);
 
 		assertNotNull(kAfter);
 		assertNotNull(kAfter.getSets());
 		assertNotNull(kAfter.getCars());
 		assertEquals(0, kAfter.getSets().size());
 		assertEquals(0, kAfter.getCars().size());
 	}
 
 	public void testEqualsEmptyMapsWith() throws Exception {
 		Kunde k1 = new Kunde("k1");
 		
 		Converter c = new Converter();
 		Object o = c.makeSimple(k1);
 		Kunde kAfter = (Kunde) c.makeComplex(o);
 
 		assertNotNull(kAfter);
 		assertNotNull(kAfter.getMap1());
 		assertNotNull(kAfter.getMap2());
 		assertEquals(0, kAfter.getMap1().size());
 		assertEquals(0, kAfter.getMap2().size());
 	}
 
 	public void testNoObjectFoundForHashCodeByMakeComplex() throws Exception {
 		Kunde k = new Kunde("Test-Kunde");
 		Adresse a = new Adresse();
 		a.setOrt("Hier");
 		k.getAdressen().add(a);
 		Map lvMap = new Hashtable();
 		lvMap.put("ADRESSE_KEY", a);
 		lvMap.put("KUNDE_KEY", k);
 
 		try {
 			Converter lvConverter = new Converter();
 			Object lvSimple = lvConverter.makeSimple(lvMap);
 			lvConverter.makeComplex(lvSimple);
 			fail("Must throw InvocationException. No object found for HashCode.");
 		} catch (InvocationException e) {
 			assertTrue(true);
 		}
 	}
 
 	public void testNoObjectFoundForHashCodeByMakeComplexInCollection() throws Exception {
 		Kunde k = new Kunde("Test-Kunde");
 		Adresse a = new Adresse();
 		a.setOrt("Hier");
 		k.getAdressen().add(a);
 		Map lvMap = new Hashtable();
 		Collection c = new ArrayList();
 		c.add(a);
 		
 		lvMap.put("ADRESSE_KEY", c);
 		lvMap.put("KUNDE_KEY", k);
 
 		try {
 			Converter lvConverter = new Converter();
 			Object lvSimple = lvConverter.makeSimple(lvMap);
 			lvConverter.makeComplex(lvSimple);
 			fail("Must throw InvocationException. No object found for HashCode.");
 		} catch (InvocationException e) {
 			assertTrue(true);
 		}
 	}
 	
 	public void testNoObjectFoundForHashCodeByMakeComplexInArray() throws Exception {
 		Kunde k = new Kunde("Test-Kunde");
 		Adresse a = new Adresse();
 		a.setOrt("Hier");
 		Adresse ar[] = new Adresse[1];
 		ar[0] = a;
 		k.setAdresseArray(ar);
 		
 		Map lvMap = new Hashtable();
 		lvMap.put("KEY_1", a);
 		lvMap.put("KEY_2", k);
 		
 		
 		Converter lvConverter = new Converter();
 		lvConverter.setWithSimpleKeyMapper(true);
 		
 		Object lvSimple = lvConverter.makeSimple(lvMap);
 		
 		assertNotNull( ((Map) lvSimple).get("1" + DELIMITER + "KEY_2"));
 		assertNotNull( ((Map) lvSimple).get("2" + DELIMITER + "KEY_1"));
 
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof Map);
 		Map lvMapAfter = (Map) lvComplex;
 		assertEquals(2, lvMapAfter.size());
 		Adresse aAfter = (Adresse) lvMapAfter.get("KEY_1");
 		Kunde kAfter = (Kunde) lvMapAfter.get("KEY_2");
 		assertEquals("Hier", aAfter.getOrt());
 		assertEquals("Test-Kunde", kAfter.getName());
 		assertEquals(1, kAfter.getAdresseArray().length);
 		assertEquals(aAfter, kAfter.getAdresseArray()[0]);
 	}
 	
 	public void testNoObjectFoundForHashCodeByMakeComplexInArrayWithException() throws Exception {
 		Adresse a = new Adresse();
 		a.setOrt("Hier");
 		Adresse ar[] = new Adresse[2];
 		ar[0] = a;
 		ar[1] = a;
 		
 		Converter lvConverter = new Converter();
 		Object lvSimple = lvConverter.makeSimple(ar);
 		
 		List l = new Vector();
 		// swap the order of the array
 		l.add(((List) lvSimple).get(1));
 		l.add(((List) lvSimple).get(0));
 		
 		try {
 			lvConverter.makeComplex(l, ar.getClass());
 			fail("Invalid order of the Array.");
 		} catch (Exception e) {
 			assertTrue(true);
 		}
 	}
 	
 	public void testNoObjectFoundForHashCodeByMakeComplexInArray_KeyOrderChange() throws Exception {
 		Kunde k = new Kunde("Test-Kunde");
 		Adresse a = new Adresse();
 		a.setOrt("Hier");
 		Adresse ar[] = new Adresse[1];
 		ar[0] = a;
 		k.setAdresseArray(ar);
 		
 		Map lvMap = new Hashtable();
 		lvMap.put("KEY_5", a);
 		lvMap.put("KEY_2", k);
 		
 		
 		Converter lvConverter = new Converter();
 		lvConverter.setWithSimpleKeyMapper(true);
 		
 		Object lvSimple = lvConverter.makeSimple(lvMap);
 		assertNotNull( ((Map) lvSimple).get("1" + DELIMITER + "KEY_5"));
 		assertNotNull( ((Map) lvSimple).get("2" + DELIMITER + "KEY_2"));
 		
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof Map);
 		Map lvMapAfter = (Map) lvComplex;
 		assertEquals(2, lvMapAfter.size());
 		Adresse aAfter = (Adresse) lvMapAfter.get("KEY_5");
 		Kunde kAfter = (Kunde) lvMapAfter.get("KEY_2");
 		assertEquals("Hier", aAfter.getOrt());
 		assertEquals("Test-Kunde", kAfter.getName());
 		assertEquals(1, kAfter.getAdresseArray().length);
 		assertEquals(aAfter, kAfter.getAdresseArray()[0]);
 	}
 
 
 	public void testObjectFoundForHashCodeByMakeComplex() throws Exception {
 		Kunde k = new Kunde("Test-Kunde");
 		Adresse a = new Adresse();
 		a.setOrt("Hier");
 		k.getAdressen().add(a);
 		Map lvMap = new Hashtable();
 		lvMap.put("ADRESSE_KEY", a);
 		lvMap.put("KUNDE_KEY", k);
 
 		Converter lvConverter = new Converter();
 		lvConverter.setWithSimpleKeyMapper(true);
 		Object lvSimple = lvConverter.makeSimple(lvMap);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof Map);
 		Map lvMapAfter = (Map) lvComplex;
 		Object lvAdrAfter = lvMapAfter.get("ADRESSE_KEY");
 		assertTrue(lvAdrAfter instanceof Adresse);
 		assertEquals("Hier", ((Adresse) lvAdrAfter).getOrt());
 		Object lvKundeAfter = lvMapAfter.get("KUNDE_KEY");
 		assertTrue(lvKundeAfter instanceof Kunde);
 		assertEquals("Test-Kunde", ((Kunde) lvKundeAfter).getName());
 	}
 
 	public void testObjectFoundForHashCodeByMakeComplex2() throws Exception {
 		Adresse a = new Adresse();
 		a.setOrt("Hier");
 		Kunde k = new Kunde("Test-Kunde");
 		k.getAdressen().add(a);
 
 		Map lvMap = new Hashtable();
 		lvMap.put("ADRESSE_KEY_3", a);
 		lvMap.put("ADRESSE_KEY_2", a);
 		lvMap.put("ADRESSE_KEY_1", a);
 		lvMap.put("ADRESSE_KEY_0", k);
 
 		Converter lvConverter = new Converter();
 		assertFalse(lvConverter.getWithSimpleKeyMapper());
 		
 		lvConverter.setWithSimpleKeyMapper(true);
 		Object lvSimple = lvConverter.makeSimple(lvMap);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof Map);
 		Map lvMapAfter = (Map) lvComplex;
 		assertEquals(4, lvMapAfter.size());
 
 		Object lvKundeAfter = lvMapAfter.get("ADRESSE_KEY_0");
 		assertTrue(lvKundeAfter instanceof Kunde);
 		assertEquals("Test-Kunde", ((Kunde) lvKundeAfter).getName());
 
 		Object lvAdrAfter1 = lvMapAfter.get("ADRESSE_KEY_1");
 		assertTrue(lvAdrAfter1 instanceof Adresse);
 		assertEquals("Hier", ((Adresse) lvAdrAfter1).getOrt());
 		
 		Object lvAdrAfter2 = lvMapAfter.get("ADRESSE_KEY_2");
 		assertTrue(lvAdrAfter2 instanceof Adresse);
 		assertEquals("Hier", ((Adresse) lvAdrAfter2).getOrt());
 
 		Object lvAdrAfter3 = lvMapAfter.get("ADRESSE_KEY_3");
 		assertTrue(lvAdrAfter3 instanceof Adresse);
 		assertEquals("Hier", ((Adresse) lvAdrAfter3).getOrt());
 		
 		assertTrue(lvConverter.getWithSimpleKeyMapper());
 	}
 	
 	public void testMakeSimpleAndComplexArrayWithSameObjects() throws Exception {
 		Converter lvConverter = new Converter();
 		
 		Adresse a = new Adresse();
 		a.setOrt("Hier");
 		Object lvArray = new Object[] {a, a, a};
 		Object lvSimple = lvConverter.makeSimple(lvArray);
 		Object lvComplex = lvConverter.makeComplex(lvSimple, new Object[0].getClass(), Adresse.class);
 		assertTrue(lvComplex.getClass().isArray());
 		Object lvArrayAfter[] = (Object[]) lvComplex;
 		assertEquals(3, lvArrayAfter.length);
 		assertEquals(a.getOrt(), ((Adresse) lvArrayAfter[0]).getOrt());
 		assertEquals(a.getOrt(), ((Adresse) lvArrayAfter[1]).getOrt());
 		assertEquals(a.getOrt(), ((Adresse) lvArrayAfter[2]).getOrt());
 	}
 
 	public void testMakeSimpleAndComplexArrayWithSameObjectsWithNullValue() throws Exception {
 		Converter lvConverter = new Converter();
 		
 		Adresse a = new Adresse();
 		a.setOrt("Hier");
 		Object lvArray = new Object[] {a, null, a};
 		Object lvSimple = lvConverter.makeSimple(lvArray);
 		Object lvComplex = lvConverter.makeComplex(lvSimple, new Object[0].getClass(), Adresse.class);
 		assertTrue(lvComplex.getClass().isArray());
 		Object lvArrayAfter[] = (Object[]) lvComplex;
 		assertEquals(2, lvArrayAfter.length);
 		assertEquals(a.getOrt(), ((Adresse) lvArrayAfter[0]).getOrt());
 		assertEquals(a.getOrt(), ((Adresse) lvArrayAfter[1]).getOrt());
 	}
 
 	public void testMakeSimpleAndComplexArrayWithSameObjectsWithNullValue2() throws Exception {
 		Converter lvConverter = new Converter("!--MyNullValue--!");
 		
 		Adresse a = new Adresse();
 		a.setOrt("Hier");
 		Object lvArray = new Object[] {a, null, a};
 		Object lvSimple = lvConverter.makeSimple(lvArray);
 		Object lvComplex = lvConverter.makeComplex(lvSimple, new Object[0].getClass(), Adresse.class);
 		assertTrue(lvComplex.getClass().isArray());
 		Object lvArrayAfter[] = (Object[]) lvComplex;
 		assertEquals(3, lvArrayAfter.length);
 		assertEquals(a.getOrt(), ((Adresse) lvArrayAfter[0]).getOrt());
 		assertNull(lvArrayAfter[1]);
 		assertEquals(a.getOrt(), ((Adresse) lvArrayAfter[2]).getOrt());
 	}
 	
 	public void testMakeComplexMapAsArray() throws Exception {
 		Map lvKunde = new Hashtable();
 		lvKunde.put("class", Kunde.class.getName());
 		lvKunde.put("name", "ICH");
 		Converter lvConverter = new Converter();
 		Object o = lvConverter.makeComplex(lvKunde, new Object[0].getClass());
 		assertNotNull(o);
 		assertTrue(o instanceof Kunde);
 		Kunde lvKundeAfter = (Kunde) o;
 		assertEquals("ICH", lvKundeAfter.getName());
 	}
 
 	public void testUniqueId() throws Exception {
 		Converter lvConverter = new Converter();
 		List l = new Vector();
 		NodeHashCode1 n1 = new NodeHashCode1("n1", 1);
 		NodeHashCode2 n2 = new NodeHashCode2("n2", 1);
 		NodeHashCode3 n3 = new NodeHashCode3("n3", 1);
 		NodeHashCode3 n32 = new NodeHashCode3("n32", 1);
 		l.add(n1);
 		l.add(n2);
 		l.add(n3);
 		l.add(n32);
 		Object lvSimple = lvConverter.makeSimple(l);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof List);
 		List lAfter = (List) lvComplex;
 		assertEquals(4, lAfter.size());
 		assertEquals(n1.getName(), ((NodeHashCode1)lAfter.get(0)).getName());
 		assertEquals(0, ((NodeHashCode1)lAfter.get(0)).hashCode());
 		
 		assertEquals(n2.getName(), ((NodeHashCode2)lAfter.get(1)).getName());
 		assertEquals(0, ((NodeHashCode2)lAfter.get(1)).hashCode());
 		
 		assertEquals(n3.getName(), ((NodeHashCode3)lAfter.get(2)).getName());
 		assertEquals(0, ((NodeHashCode3)lAfter.get(2)).hashCode());
 
 		assertEquals(n32.getName(), ((NodeHashCode3)lAfter.get(3)).getName());
 		assertEquals(0, ((NodeHashCode3)lAfter.get(3)).hashCode());
 	}
 	
 	public void testMakeSimpleTwice() throws Exception {
 		Kunde k = new Kunde("Test-Kunde");
 		k.setDate(new Date());
 		k.setVorname("Vorname");
 
 		Converter lvConverter = new Converter();
 		Object lvSimple = lvConverter.makeSimple(k);
 		Object lvSimple2 = lvConverter.makeSimple(lvSimple);
 
 		assertEquals(lvSimple, lvSimple2);
 	}
 	
 	public void testMakeSimpleTwice_2() throws Exception {
 		Kunde k = new Kunde("Test-Kunde");
 		k.setDate(new Date());
 		k.setVorname("Vorname");
 		Adresse a = new Adresse();
 		a.setOrt("Hier");
 		List l = new ArrayList();
 		l.add(a);
 		k.setAdressen(l);
 
 		Converter lvConverter = new Converter();
 		Object lvSimple = lvConverter.makeSimple(k);
 		Object lvSimple2 = lvConverter.makeSimple(lvSimple);
 
 		assertEquals(lvSimple, lvSimple2);
 	}
 
 
 	public void testMakeSimpleThreeAndBack() throws Exception {
 		Car lvCar = new Car();
 		lvCar.setName("Ferrari");
 
 		Converter lvConverter = new Converter();
 		lvConverter.setWithSimpleKeyMapper(true);
 		Object lvSimple = lvConverter.makeSimple(lvCar);
 		Object lvSimple2 = lvConverter.makeSimple(lvSimple);
 		Object lvSimple3 = lvConverter.makeSimple(lvSimple);
 		assertFalse(lvSimple.equals(lvSimple3));
 		assertEquals(lvSimple2, lvSimple3);
 		
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertTrue(lvComplex instanceof Car);
 		assertEquals("Ferrari", ((Car) lvComplex).getName());
 		
 		Object lvComplex2 = lvConverter.makeComplex(lvSimple2);
 		assertTrue(lvComplex2 instanceof Map);
 		assertEquals(Car.class.getName(), ((Map) lvComplex2).get("class"));
 		
 		lvComplex2 = lvConverter.makeComplex(lvComplex2);
 		assertTrue(lvComplex2 instanceof Car);
 		assertEquals("Ferrari", ((Car) lvComplex2).getName());
 	}
 
 	public void testConvertJavaUtilProperties() throws Exception {
 		Converter lvConverter = new Converter();
 		lvConverter.setWithSimpleKeyMapper(true);
 		
 		Properties lvProperties = new Properties();
 		Object lvSimple = lvConverter.makeSimple(lvProperties);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof Hashtable);
 	}
 	
 	public void testConvertJavaUtilPropertiesAsClassProperty() throws Exception {
 		Converter lvConverter = new Converter();
 		lvConverter.setWithSimpleKeyMapper(true);
 		
 		Properties lvProperties = new Properties();
 		Car lvCar = new Car();
 		lvCar.setName("BMW");
 		lvCar.setProperties(lvProperties);
 		
 		Object lvSimple = lvConverter.makeSimple(lvCar);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof Car);
 		Car lvCarAfter = (Car) lvComplex;
 		assertEquals(new Properties(), lvCarAfter.getProperties());
 	}
 	
 	public void testConvertJavaUtilPropertiesAsClassProperty_2() throws Exception {
 		Converter lvConverter = new Converter();
 		lvConverter.setWithSimpleKeyMapper(true);
 		
 		Properties lvProperties = new Properties();
 		lvProperties.put("aa", "bb");
 		Car lvCar = new Car();
 		lvCar.setName("BMW");
 		lvCar.setProperties(lvProperties);
 		
 		Object lvSimple = lvConverter.makeSimple(lvCar);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertNotNull(lvComplex);
 		assertTrue(lvComplex instanceof Car);
 		Car lvCarAfter = (Car) lvComplex;
 		assertNotNull(lvCarAfter.getProperties());
 		assertEquals(1, lvCarAfter.getProperties().size());
 		assertEquals("bb", lvCarAfter.getProperties().getProperty("aa"));
 	}
 	
 	public void testBeanWithGetterOfTypeObjectAsList() throws Exception {
 		Status lvStatus = new Status("MyStatus");
 		List lvList = new ArrayList();
 		lvList.add("String");
 		lvStatus.setResult(lvList);
 		
 		Converter lvConverter = new Converter();
 		Object lvResult = lvConverter.makeSimple(lvStatus);
 		Map lvMap = (Map) lvResult;
 		List lvListAfter = new Vector();
 		lvListAfter.add("String");
 		assertEquals(lvListAfter, lvMap.get("result"));
 
 		
 		lvResult = lvConverter.makeComplex(lvResult);
 		Status lvStatusAfter = (Status) lvResult;
 		assertEquals(lvListAfter, lvStatusAfter.getResult());
 	}
 	
 	public void testBeanWithGetterOfTypeObjectAsMap() throws Exception {
 		Status lvStatus = new Status("MyStatus");
 		Map lvMap = new HashMap();
 		lvMap.put("Key", "Value");
 		lvStatus.setResult(lvMap);
 		
 		Converter lvConverter = new Converter();
 		Object lvResult = lvConverter.makeSimple(lvStatus);
 		Map lvMapSimple = (Map) lvResult;
 		Map lvMapAfter = new Hashtable();
 		lvMapAfter.put("Key", "Value");
 		assertEquals(lvMapAfter, lvMapSimple.get("result"));
 
 		
 		lvResult = lvConverter.makeComplex(lvResult);
 		Status lvStatusAfter = (Status) lvResult;
 		assertEquals(lvMapAfter, lvStatusAfter.getResult());
 	}
 
 	public void testBeanWithGetterOfTypeObjectAsString() throws Exception {
 		Status lvStatus = new Status("MyStatus");
 		lvStatus.setResult("Result");
 		
 		Converter lvConverter = new Converter();
 		Object lvResult = lvConverter.makeSimple(lvStatus);
 		Map lvMapSimple = (Map) lvResult;
 		assertEquals("Result", lvMapSimple.get("result"));
 
 		
 		lvResult = lvConverter.makeComplex(lvResult);
 		Status lvStatusAfter = (Status) lvResult;
 		assertEquals("Result", lvStatusAfter.getResult());
 	}
 
 	public void testBeanWithGetterOfTypeObjectAsLong() throws Exception {
 		Status lvStatus = new Status("MyStatus");
 		lvStatus.setResult(new Long("4711"));
 		
 		Converter lvConverter = new Converter();
 		Object lvResult = lvConverter.makeSimple(lvStatus);
 		Map lvMapSimple = (Map) lvResult;
 		assertEquals(new Integer("4711"), lvMapSimple.get("result"));
 
 		
 		lvResult = lvConverter.makeComplex(lvResult);
 		Status lvStatusAfter = (Status) lvResult;
 		assertEquals(new Integer("4711"), lvStatusAfter.getResult());
 	}
 
 	public void testSameEmptyListsOnTheSameBean() throws Exception {
 		Converter lvConverter = new Converter("NULL!!!!jhgfjhvjhdgfkjhgfdhjfdgfdjgh");
 		DataTransferObject lvDataTransferObject = new DataTransferObject();
 		LinkedList lvLinkedList = new LinkedList();
 		lvDataTransferObject.setReturnObject(lvLinkedList);
 		lvDataTransferObject.setParams(lvLinkedList);
 		lvDataTransferObject.setParamtypes(null);
 		Object lvSimple = lvConverter.makeSimple(lvDataTransferObject);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		DataTransferObject lvDataTransferObject2 = (DataTransferObject)lvComplex;
 		assertNotNull(lvDataTransferObject2.getReturnObject());
 		assertEquals(new Vector(), lvDataTransferObject2.getReturnObject());
 	}
 
 	public void testDifferentEmptyListsOnTheSameBean() throws Exception {
 		Converter lvConverter = new Converter("NULL!!!!jhgfjhvjhdgfkjhgfdhjfdgfdjgh");
 		DataTransferObject lvDataTransferObject = new DataTransferObject();
 		lvDataTransferObject.setReturnObject(new LinkedList());
 		lvDataTransferObject.setParams(new LinkedList());
 		lvDataTransferObject.setParamtypes(null);
 		Object lvSimple = lvConverter.makeSimple(lvDataTransferObject);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		DataTransferObject lvDataTransferObject2 = (DataTransferObject)lvComplex;
 		assertNotNull(lvDataTransferObject2.getReturnObject());
 		assertEquals(new Vector(), lvDataTransferObject2.getReturnObject());
 	}
 
 	public void testSameNotEmptyListsOnTheSameBean() throws Exception {
 		Converter lvConverter = new Converter("NULL!!!!jhgfjhvjhdgfkjhgfdhjfdgfdjgh");
 		DataTransferObject lvDataTransferObject = new DataTransferObject();
 		LinkedList lvLinkedList = new LinkedList();
 		lvLinkedList.add("MyString");
 		lvDataTransferObject.setReturnObject(lvLinkedList);
 		lvDataTransferObject.setParams(lvLinkedList);
 		lvDataTransferObject.setParamtypes(null);
 		Object lvSimple = lvConverter.makeSimple(lvDataTransferObject);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		DataTransferObject lvDataTransferObject2 = (DataTransferObject)lvComplex;
 		assertNotNull(lvDataTransferObject2.getReturnObject());
 		
 		Vector v = new Vector();
 		v.add("MyString");
 		assertEquals(v, lvDataTransferObject2.getReturnObject());
 	}
 
 	public void testListWithNullValue() throws Exception {
 		Converter lvConverter = new Converter();
 		List l = new ArrayList();
 		l.add("String 1");
 		l.add(null);
 		l.add("String 2");
 		
 		Object lvSimple = lvConverter.makeSimple(l);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);		
 		List lAfter = (List) lvComplex;
 		assertEquals(l.size() - 1, lAfter.size());
 		
 		lvConverter.setNullValue("--Null--Value--");
 		lvSimple = lvConverter.makeSimple(l);
 		lvComplex = lvConverter.makeComplex(lvSimple);		
 		lAfter = (List) lvComplex;
 		assertEquals(l.size(), lAfter.size());
 	}
 	
 	public void testSimpleLongValueByObjectProperty() throws Exception {
 		Converter lvConverter = new Converter();
 		DataTransferObject lvDataTransferObject = new DataTransferObject();
 		lvDataTransferObject.setReturnObject(new Long("4711"));
 		Object lvSimple = lvConverter.makeSimple(lvDataTransferObject);
 		Object lvComplex = lvConverter.makeComplex(lvSimple);
 		assertNotNull(lvComplex);
 		DataTransferObject lvDataTransferObjectAfter = (DataTransferObject) lvComplex;
 		assertEquals(new Integer("4711"), lvDataTransferObjectAfter.getReturnObject());
 	}
 }