mappertest.java

一个javabean的转换与copy非常的好用希望大家好好研究一下

  }

  public void testMappingNoDestSpecified() throws Exception {
    // Map
    House src = TestDataFactory.getHouse();
    HomeDescription dest = (HomeDescription) mapper.map(src, HomeDescription.class);
    House src2 = (House) mapper.map(dest, House.class);
    HomeDescription dest2 = (HomeDescription) mapper.map(src2, HomeDescription.class);

    long[] prim = { 1, 2, 3, 1, 2, 3 };
    // cumulative relationship
    dest.setPrim(prim);
    assertEquals(dest, dest2);

    // By reference
    src = TestDataFactory.getHouse();
    House houseClone = (House) SerializationUtils.clone(src);
    dest = (HomeDescription) mapper.map(src, HomeDescription.class);
    mapper.map(dest, House.class);
    assertEquals(houseClone, src);
  }

  public void testGeneralMappingPassByReference() throws Exception {
    // Map
    TestObject to = TestDataFactory.getInputGeneralMappingTestObject();
    TestObject toClone = (TestObject) SerializationUtils.clone(to);
    TestObjectPrime prime = (TestObjectPrime) mapper.map(to, TestObjectPrime.class);
    mapper.map(prime, to);
    // more objects should be added to the clone from the ArrayList
    TheFirstSubClass fsc = new TheFirstSubClass();
    fsc.setS("s");
    toClone.getHintList().add(fsc);
    toClone.getHintList().add(fsc);
    toClone.getEqualNamedList().add("1value");
    toClone.getEqualNamedList().add("2value");
    int[] pa = { 0, 1, 2, 3, 4, 0, 1, 2, 3, 4 };
    int[] intArray = { 1, 1, 1, 1 };
    Integer[] integerArray = { new Integer(1), new Integer(1), new Integer(1), new Integer(1) };
    toClone.setAnArray(intArray);
    toClone.setArrayForLists(integerArray);
    toClone.setPrimArray(pa);
    toClone.setBlankDate(null);
    toClone.setBlankStringToLong(null);
    // since we copy by reference the attribute copyByReference we need to null it out. The clone method above creates
    // two versions of it...
    // which is incorrect
    to.setCopyByReference(null);
    toClone.setCopyByReference(null);
    to.setCopyByReferenceDeep(null);
    toClone.setCopyByReferenceDeep(null);
    to.setGlobalCopyByReference(null);
    toClone.setGlobalCopyByReference(null);
    // null out string array because we get NPE since a NULL value in the String []
    to.setStringArrayWithNullValue(null);
    toClone.setStringArrayWithNullValue(null);
    toClone.setExcludeMeOneWay("excludeMeOneWay");
    assertEquals(toClone, to);
  }

  public void testLongToLongMapping() throws Exception {
    // Map
    TestObject source = TestDataFactory.getInputGeneralMappingTestObject();
    source.setAnotherLongValue(42);
    TestObjectPrime prime2 = (TestObjectPrime) mapper.map(source, TestObjectPrime.class);
    Long value = prime2.getTheLongValue();
    assertEquals(value.longValue(), 42);
  }

  public void testSuperClassMapping() throws Exception {
    SubClass obj = TestDataFactory.getSubClass();
    SubClassPrime objPrime = (SubClassPrime) mapper.map(obj, SubClassPrime.class);
    SubClass obj2 = (SubClass) mapper.map(objPrime, SubClass.class);
    SubClassPrime objPrime2 = (SubClassPrime) mapper.map(obj2, SubClassPrime.class);

    assertEquals("" + obj.getCustomConvert().getAttribute().getTheDouble(), obj2.getCustomConvert().getAttribute()
        .getTheDouble()
        + "");

    // what is this doing??
    objPrime.setCustomConvert(null);
    objPrime2.setCustomConvert(null);
    // one-way mapping
    objPrime.setSuperFieldToExcludePrime(null);
    assertEquals(objPrime, objPrime2);

    // Pass by reference
    obj = TestDataFactory.getSubClass();
    SubClass subClassClone = (SubClass) SerializationUtils.clone(obj);
    objPrime = (SubClassPrime) mapper.map(obj, SubClassPrime.class);
    mapper.map(objPrime, obj);
    obj.setCustomConvert(null);
    subClassClone.setCustomConvert(null);
    // more objects should be added to the clone from the ArrayList
    TheFirstSubClass fsc = new TheFirstSubClass();
    fsc.setS("s");
    subClassClone.getTestObject().getHintList().add(fsc);
    subClassClone.getTestObject().getHintList().add(fsc);
    subClassClone.getTestObject().getEqualNamedList().add("1value");
    subClassClone.getTestObject().getEqualNamedList().add("2value");
    int[] pa = { 0, 1, 2, 3, 4, 0, 1, 2, 3, 4 };
    int[] intArray = { 1, 1, 1, 1 };
    Integer[] integerArray = { new Integer(1), new Integer(1), new Integer(1), new Integer(1) };
    subClassClone.getTestObject().setAnArray(intArray);
    subClassClone.getTestObject().setArrayForLists(integerArray);
    subClassClone.getTestObject().setPrimArray(pa);
    subClassClone.getTestObject().setBlankDate(null);
    subClassClone.getTestObject().setBlankStringToLong(null);
    subClassClone.getSuperList().add("one");
    subClassClone.getSuperList().add("two");
    subClassClone.getSuperList().add("three");
    // since we copy by reference the attribute copyByReference we need to null it out. The clone method above creates
    // two versions of it...
    // which is incorrect
    obj.getTestObject().setCopyByReference(null);
    subClassClone.getTestObject().setCopyByReference(null);
    obj.getTestObject().setCopyByReferenceDeep(null);
    subClassClone.getTestObject().setCopyByReferenceDeep(null);
    obj.getTestObject().setGlobalCopyByReference(null);
    subClassClone.getTestObject().setGlobalCopyByReference(null);
    // null out string array because we get NPE since a NULL value in the String []
    obj.getTestObject().setStringArrayWithNullValue(null);
    subClassClone.getTestObject().setStringArrayWithNullValue(null);
    subClassClone.getTestObject().setExcludeMeOneWay("excludeMeOneWay");
    assertEquals(subClassClone, obj);
  }

  public void testSuperClassMapping2() throws Exception {
    // source object does not extend a base custom data object, but destination object extends a custom data object.
    NoSuperClass src = new NoSuperClass();
    src.setAttribute("somefieldvalue");
    src.setSuperAttribute("someotherfieldvalue");

    SubClass dest = (SubClass) mapper.map(src, SubClass.class);
    NoSuperClass src1 = (NoSuperClass) mapper.map(dest, NoSuperClass.class);
    SubClass dest2 = (SubClass) mapper.map(src1, SubClass.class);

    assertEquals(src, src1);
    assertEquals(dest, dest2);
  }

  public void testInheritance() throws Exception {
    // first test mapping of sub and base class to a single class
    net.sf.dozer.util.mapping.vo.inheritance.SubClass sub = new net.sf.dozer.util.mapping.vo.inheritance.SubClass();

    sub.setBaseAttribute("base");
    sub.setSubAttribute("sub");

    BaseSubClassCombined combined = (BaseSubClassCombined) mapper.map(sub, BaseSubClassCombined.class);

    assertEquals(sub.getSubAttribute(), combined.getSubAttribute2());
    assertEquals(sub.getBaseAttribute(), combined.getBaseAttribute2());
  }

  public void testInheritance2() throws Exception {
    // test base to base and sub to sub mapping with an intermediate on the destination
    AnotherSubClass asub = new AnotherSubClass();
    asub.setBaseAttribute("base");
    asub.setSubAttribute("sub");
    List list = new ArrayList();
    SClass s = new SClass();
    s.setBaseSubAttribute("sBase");
    s.setSubAttribute("s");
    S2Class s2 = new S2Class();
    s2.setBaseSubAttribute("s2Base");
    s2.setSub2Attribute("s2");
    list.add(s2);
    list.add(s);
    asub.setSubList(list);

    List list2 = new ArrayList();
    SClass sclass = new SClass();
    sclass.setBaseSubAttribute("sBase");
    sclass.setSubAttribute("s");
    S2Class s2class = new S2Class();
    s2class.setBaseSubAttribute("s2Base");
    s2class.setSub2Attribute("s2");
    SClass sclass2 = new SClass();
    sclass2.setBaseSubAttribute("sclass2");
    sclass2.setSubAttribute("sclass2");
    list2.add(s2class);
    list2.add(sclass);
    list2.add(sclass2);
    asub.setListToArray(list2);

    SClass sclassA = new SClass();
    SClass sclassB = new SClass();
    sclassA.setBaseSubAttribute("sBase");
    sclassA.setSubAttribute("s");
    sclassB.setBaseSubAttribute("sBase");
    sclassB.setSubAttribute("s");
    asub.setSClass(sclassA);
    asub.setSClass2(sclassB);

    AnotherSubClassPrime subPrime = (AnotherSubClassPrime) mapper.map(asub, AnotherSubClassPrime.class);

    assertEquals(asub.getSubAttribute(), subPrime.getSubAttribute2());
    assertEquals(asub.getBaseAttribute(), subPrime.getBaseAttribute2());
    assertTrue(subPrime.getTheListOfSubClassPrime().get(0) instanceof S2ClassPrime);
    assertTrue(subPrime.getTheListOfSubClassPrime().get(1) instanceof SClassPrime);
    assertEquals(s2.getSub2Attribute(), ((S2ClassPrime) subPrime.getTheListOfSubClassPrime().get(0))
        .getSub2Attribute2());
    assertEquals(s2.getBaseSubAttribute(), ((S2ClassPrime) subPrime.getTheListOfSubClassPrime().get(0))
        .getBaseSubAttribute2());
    assertEquals(s.getSubAttribute(), ((SClassPrime) subPrime.getTheListOfSubClassPrime().get(1)).getSubAttribute2());
    assertEquals(s.getBaseSubAttribute(), ((SClassPrime) subPrime.getTheListOfSubClassPrime().get(1))
        .getBaseSubAttribute2());
    assertTrue(subPrime.getArrayToList()[0] instanceof S2ClassPrime);
    assertTrue(subPrime.getArrayToList()[1] instanceof SClassPrime);
    assertTrue(subPrime.getArrayToList()[2] instanceof SClassPrime);
    assertEquals(s2class.getSub2Attribute(), ((S2ClassPrime) subPrime.getArrayToList()[0]).getSub2Attribute2());
    assertEquals(s2class.getBaseSubAttribute(), ((S2ClassPrime) subPrime.getArrayToList()[0]).getBaseSubAttribute2());
    assertEquals(sclass.getSubAttribute(), ((SClassPrime) subPrime.getArrayToList()[1]).getSubAttribute2());
    assertEquals(sclass.getBaseSubAttribute(), ((SClassPrime) subPrime.getArrayToList()[1]).getBaseSubAttribute2());
    assertEquals(sclass2.getSubAttribute(), ((SClassPrime) subPrime.getArrayToList()[2]).getSubAttribute2());
    assertEquals(sclass2.getBaseSubAttribute(), ((SClassPrime) subPrime.getArrayToList()[2]).getBaseSubAttribute2());
    assertEquals(asub.getSClass().getSubAttribute(), subPrime.getSClass().getSubAttribute2());
    assertEquals(asub.getSClass().getBaseSubAttribute(), subPrime.getSClass().getBaseSubAttribute2());
    assertEquals(asub.getSClass2().getSubAttribute(), subPrime.getSClass2().getSubAttribute2());
    assertEquals(asub.getSClass2().getBaseSubAttribute(), subPrime.getSClass2().getBaseSubAttribute2());

    // map it back
    AnotherSubClass sub = (AnotherSubClass) mapper.map(subPrime, AnotherSubClass.class);
    assertTrue(sub.getSubList().get(0) instanceof S2Class);
    assertTrue(sub.getSubList().get(1) instanceof SClass);
    assertEquals(s2.getSub2Attribute(), ((S2Class) sub.getSubList().get(0)).getSub2Attribute());
    assertEquals(s2.getBaseSubAttribute(), ((S2Class) sub.getSubList().get(0)).getBaseSubAttribute());
    assertEquals(s.getSubAttribute(), ((SClass) sub.getSubList().get(1)).getSubAttribute());
    assertEquals(s.getBaseSubAttribute(), ((SClass) sub.getSubList().get(1)).getBaseSubAttribute());
  }

  public void testInheritanceWithAbstractClassOrInterfaceAsDestination() throws Exception {
    SpecificObject so = new SpecificObject();
    so.setSuperAttr1("superAttr1");

    // validate abstract class
    Object obj = mapper.map(so, GenericAbstractSuper.class);
    assertTrue(obj instanceof Specific3);
    Specific3 spec3 = (Specific3) obj;
    assertEquals("superAttr1", spec3.getSuperAttr3());
    assertEquals("superAttr1", spec3.getSuperAttr2());

    // validate interface
    obj = mapper.map(so, GenericIF.class);
    assertTrue(obj instanceof Specific3);
    spec3 = (Specific3) obj;
    assertEquals("superAttr1", spec3.getSuperAttr3());
    assertEquals("superAttr1", spec3.getSuperAttr2());

    WrapperSpecific ws = new WrapperSpecific();
    SpecificObject so2 = new SpecificObject();
    so2.setSuperAttr1("superAttr1");
    ws.setSpecificObject(so2);
    WrapperSpecificPrime wsp = (WrapperSpecificPrime) mapper.map(ws, WrapperSpecificPrime.class);
    assertTrue(wsp.getSpecificObjectPrime() instanceof Specific3);
    assertEquals("superAttr1", ((Specific3) wsp.getSpecificObjectPrime()).getSuperAttr3());
    assertEquals("superAttr1", ((Specific3) wsp.getSpecificObjectPrime()).getSuperAttr2());
  }

  public void testNoWildcards() throws Exception {
    // Map
    FurtherTestObjectPrime prime = (FurtherTestObjectPrime) mapper.map(TestDataFactory
        .getInputTestNoWildcardsFurtherTestObject(), FurtherTestObjectPrime.class);
    FurtherTestObject source = (FurtherTestObject) mapper.map(prime, FurtherTestObject.class);
    FurtherTestObjectPrime prime2 = (FurtherTestObjectPrime) mapper.map(source, FurtherTestObjectPrime.class);
    assertEquals(prime2, prime);
  }

  public void testHydrateAndMore() throws Exception {
    HydrateTestObject dest = (HydrateTestObject) mapper.map(TestDataFactory
        .getInputTestHydrateAndMoreDehydrateTestObject(), HydrateTestObject.class);
    // validate results
    assertEquals(TestDataFactory.getExpectedTestHydrateAndMoreHydrateTestObject(), dest);

    // map it back
    DehydrateTestObject dhto = (DehydrateTestObject) mapper.map(TestDataFactory
        .getInputTestHydrateAndMoreHydrateTestObject(), DehydrateTestObject.class);
    assertEquals(TestDataFactory.getExpectedTestHydrateAndMoreDehydrateTestObject(), dhto);
  }

  public void testDeepProperties() throws Exception {
    House src = TestDataFactory.getHouse();
    HomeDescription dest = (HomeDescription) mapper.map(src, HomeDescription.class);
    House src2 = (House) mapper.map(dest, House.class);
    HomeDescription dest2 = (HomeDescription) mapper.map(src2, HomeDescription.class);

    long[] prim = { 1, 2, 3, 1, 2, 3 };
    // cumulative relationship
    dest.setPrim(prim);
    assertEquals(dest, dest2);

    // By reference
    src = TestDataFactory.getHouse();
    House houseClone = (House) SerializationUtils.clone(src);
    dest = (HomeDescription) mapper.map(src, HomeDescription.class);
    mapper.map(dest, src);
    // cumulative relationship