private void configureMapperFactory(MapperFactory factory) { factory.registerClassMap(ClassMapBuilder.map(Policy.class, PolicyDTO.class).byDefault().toClassMap()); factory.registerClassMap(ClassMapBuilder.map(CustomerElement.class, CustomerElementDTO.class).byDefault().toClassMap()); factory.registerClassMap(ClassMapBuilder.map(ProductElement.class, ProductElementDTO.class).byDefault().toClassMap()); factory.registerClassMap(ClassMapBuilder.map(OtherElement.class, OtherElementDTO.class).byDefault().toClassMap()); factory.registerClassMap(ClassMapBuilder.map(OneOtherElement.class, OneOtherElementDTO.class).byDefault().toClassMap()); }
@SuppressWarnings("deprecation") @Test public void testMappingEmptyArray() { MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build(); mapperFactory.registerClassMap(ClassMapBuilder.map(Object.class,Object.class).byDefault().toClassMap()); List<Object> listA = new ArrayList<Object>(); List<Object> listB = mapperFactory.getMapperFacade().mapAsList(listA, Object.class); Assert.assertNotNull(listB); Assert.assertTrue(listB.isEmpty()); }
@Before public void setUp() { MapperFactory mapperFactory = createMapperFactory(); mapperFactory.registerClassMap(mapperFactory.classMap(Order.class, OrderData.class).byDefault().toClassMap()); mapperFactory.registerClassMap(mapperFactory.classMap(Position.class, PositionData.class).byDefault().toClassMap()); facade = mapperFactory.getMapperFacade(); }
@Test public void testMappingToStringArray_empty() { final MapperFactory mapperFactory = new DefaultMapperFactory.Builder() .build(); final ClassMapBuilder<A, B> builder = ClassMapBuilder.map(A.class, B.class); mapperFactory.registerClassMap(builder.byDefault().toClassMap()); final MapperFacade facade = mapperFactory.getMapperFacade(); final A a = new A(); final B converted = facade.map(a, B.class); Assert.assertNotNull(converted); Assert.assertNull(converted.getList()); }
@Test public void testMappingToStringToPrimitiveArray_empty() { final MapperFactory mapperFactory = new DefaultMapperFactory.Builder() .build(); final ClassMapBuilder<A, C> builder = ClassMapBuilder.map(A.class, C.class); mapperFactory.registerClassMap(builder.byDefault().toClassMap()); final MapperFacade facade = mapperFactory.getMapperFacade(); final A a = new A(); final C converted = facade.map(a, C.class); Assert.assertNotNull(converted); Assert.assertNull(converted.getList()); }
@Override public void configure(MapperFactory factory) { factory.registerClassMap(factory.classMap(MySourceObject.class, MyTargetObject.class)// .field("e", "sub.s") .toClassMap()); factory.getConverterFactory().registerConverter(new MyEnumConverter()); } };
@Override public void configure(MapperFactory factory) { factory.getConverterFactory().registerConverter(new MyEnumConverter()); factory.registerClassMap( // factory.classMap(MySourceObject.class, MyTargetObject.class)// .field("e", "sub.e") .toClassMap()); } };
@Override public void configure(MapperFactory factory) { factory.registerClassMap(factory.classMap(MySourceObject.class, MyTargetObject.class).field("e", "directE") .toClassMap()); factory.getConverterFactory().registerConverter(new MyEnumConverter()); } };
@Test public void resolveConcreteClass() { MapperFacade mapper = factory.getMapperFacade(); factory.registerClassMap(ClassMapBuilder.map(ChildEntity.class, ChildDTO.class).byDefault().toClassMap()); factory.build(); ChildEntity entity = new ChildEntity(); entity.setId(1L); entity.setName("Khettabi"); BaseDTO dto = mapper.map(entity, BaseDTO.class); Assert.assertTrue(dto instanceof ChildDTO); Assert.assertEquals(entity.getName(), ((ChildDTO) dto).getName()); }
protected void configure(MapperFactory mapperFactory) { mapperFactory.getConverterFactory().registerConverter(new CustomConverter<Address, String>() { public String convert(Address source, Type<? extends String> destinationType) { return source.getLine1() + " " + source.getLine2(); } }); ClassMapBuilder<Order, OrderDTO> classMapBuilder = ClassMapBuilder.map(Order.class, OrderDTO.class); classMapBuilder.fieldMap("customer.address", "shippingAddress").add(); mapperFactory.registerClassMap(classMapBuilder.byDefault().toClassMap()); }
@Test public void testMapping() { MapperFactory mapperFactory = MappingUtil.getMapperFactory(); mapperFactory.getConverterFactory().registerConverter(new OrderIdConverter()); ClassMapBuilder<Order, OrderData> builder = ClassMapBuilder.map(Order.class, OrderData.class); ClassMap<Order, OrderData> classMap = builder.field("id", "number").byDefault().toClassMap(); mapperFactory.registerClassMap(classMap); MapperFacade facade = mapperFactory.getMapperFacade(); OrderData data = new OrderData(1234l); Order order = facade.map(data, Order.class); Assert.assertEquals(Long.valueOf(1234l), order.getId()); }
@Before public void setUp() { mapperFactory = MappingUtil.getMapperFactory(); ClassMap<LineDTO, Line> classMap = ClassMapBuilder.map(LineDTO.class, Line.class).field("x0", "start.x").field("y0", "start.y") .field("x1", "end.x").field("y1", "end.y").toClassMap(); mapperFactory.registerClassMap(classMap); mapperFactory.build(); }
@Test public void testConvertLongString() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.getConverterFactory().registerConverter(new LongToStringConverter()); factory.registerClassMap(ClassMapBuilder.map(A.class, B.class).field("id", "string").toClassMap()); factory.build(); A source = new A(); source.setId(42L); B destination = factory.getMapperFacade().map(source, B.class); Assert.assertEquals("42", destination.getString()); }
@Test public void testLookupDestinationGetsMostSpecific() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap(ClassMapBuilder.map(A.class, BSub.class).byDefault().toClassMap()); factory.registerClassMap(ClassMapBuilder.map(A.class, B.class).byDefault().toClassMap()); factory.registerClassMap(ClassMapBuilder.map(A.class, BSuper.class).byDefault().toClassMap()); factory.getMapperFacade(); Type bsuper = factory.lookupConcreteDestinationType(TypeFactory.valueOf(A.class), TypeFactory.valueOf(BSuper.class), null); Assert.assertEquals(BSuper.class, bsuper.getRawType()); Type b = factory.lookupConcreteDestinationType(TypeFactory.valueOf(A.class), TypeFactory.valueOf(B.class), null); Assert.assertEquals(B.class, b.getRawType()); Type bsub = factory.lookupConcreteDestinationType(TypeFactory.valueOf(A.class), TypeFactory.valueOf(BSub.class), null); Assert.assertEquals(BSub.class, bsub.getRawType()); }
@Test public void testMapping() { MapperFactory mapperFactory = MappingUtil.getMapperFactory(); mapperFactory.registerClassMap( mapperFactory.classMap(Order.class, OrderData.class) .field("entityID", "orderId").byDefault().toClassMap()); mapperFactory.getConverterFactory().registerConverter(new OrderIDConverter()); MapperFacade facade = mapperFactory.getMapperFacade(); OrderData data = new OrderData(1234l); Order order = facade.map(data, Order.class); Assert.assertEquals(new OrderID(1234l), order.getEntityID()); } }
@Test public void testAvoidEmptyObjectCreation() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap(ClassMapBuilder.map(A.class, B.class).field("b.i1", "i1").field("b.i2", "i2").toClassMap()); MapperFacade mapperFacade = factory.getMapperFacade(); B b = new B(); b.i1 = null; b.i2 = null; A result = mapperFacade.map(b, A.class); Assert.assertNull(result.b); b.i1 = 2; b.i2 = null; }
@Test public void simpleCase() { MapperFactory factory = new DefaultMapperFactory.Builder().build(); factory.registerClassMap(factory.classMap(Bean.class, Bean.class) .byDefault().toClassMap()); MapperFacade mapper = factory.getMapperFacade(); Bean bean = new Bean(); bean.setSize(20); bean.setName("Kidney"); mapper.map(bean, Bean.class); /* If map pass no need to check */ }
@Test public void testPrimtiveToWrapper() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap(ClassMapBuilder.map(Primitive.class, Wrapper.class).field("primitive", "wrapper").toClassMap()); factory.build(); MapperFacade mapper = factory.getMapperFacade(); Wrapper source = new Wrapper(); source.setWrapper(true); Primitive destination = mapper.map(source, Primitive.class); Assert.assertEquals(Boolean.TRUE, destination.isPrimitive()); }
@Test public void testWrapperToPrimtive() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap(ClassMapBuilder.map(Wrapper.class, Primitive.class).field("wrapper", "primitive").toClassMap()); factory.build(); MapperFacade mapper = factory.getMapperFacade(); Primitive source = new Primitive(); source.setPrimitive(true); Wrapper destination = mapper.map(source, Wrapper.class); Assert.assertEquals(true, destination.getWrapper()); }
@Test public void testCreateDestinationIfNotNull() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap(ClassMapBuilder.map(A.class, B.class).field("b.i1", "i1").field("b.i2", "i2").toClassMap()); MapperFacade mapperFacade = factory.getMapperFacade(); B b = new B(); b.i1 = 2; b.i2 = 3; A result = mapperFacade.map(b, A.class); Assert.assertNotNull(result.b); Assert.assertEquals(b.i1, result.b.i1); Assert.assertEquals(b.i2, result.b.i2); }