/* * Copyright 1999-2011 Alibaba Group. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.alibaba.dubbo.common.utils; import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import java.lang.reflect.Method; import java.lang.reflect.Type; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.UUID; import org.junit.Assert; import org.junit.Test; import com.alibaba.dubbo.common.model.Person; import com.alibaba.dubbo.common.model.SerializablePerson; import com.alibaba.dubbo.common.model.person.BigPerson; import com.alibaba.dubbo.common.model.person.FullAddress; import com.alibaba.dubbo.common.model.person.PersonInfo; import com.alibaba.dubbo.common.model.person.PersonStatus; import com.alibaba.dubbo.common.model.person.Phone; /** * @author ding.lid */ public class PojoUtilsTest { public void assertObject(Object data) { assertObject(data, null); } public void assertObject(Object data, Type type) { Object generalize = PojoUtils.generalize(data); Object realize = PojoUtils.realize(generalize, data.getClass(), type); assertEquals(data, realize); } public <T> void assertArrayObject(T[] data) { Object generalize = PojoUtils.generalize(data); @SuppressWarnings("unchecked") T[] realize = (T[]) PojoUtils.realize(generalize, data.getClass()); assertArrayEquals(data, realize); } @Test public void test_primitive() throws Exception { assertObject(Boolean.TRUE); assertObject(Boolean.FALSE); assertObject(Byte.valueOf((byte) 78)); assertObject('a'); assertObject('中'); assertObject(Short.valueOf((short) 37)); assertObject(78); assertObject(123456789L); assertObject(3.14F); assertObject(3.14D); } @Test public void test_pojo() throws Exception { assertObject(new Person()); assertObject(new SerializablePerson()); } @Test public void test_Map_List_pojo() throws Exception { Map<String, List<Object>> map = new HashMap<String, List<Object>>(); List<Object> list = new ArrayList<Object>(); list.add(new Person()); list.add(new SerializablePerson()); map.put("k", list); Object generalize = PojoUtils.generalize(map); Object realize = PojoUtils.realize(generalize, Map.class); assertEquals(map, realize); } @Test public void test_PrimitiveArray() throws Exception { assertObject(new boolean[] { true, false }); assertObject(new Boolean[] { true, false, true }); assertObject(new byte[] { 1, 12, 28, 78 }); assertObject(new Byte[] { 1, 12, 28, 78 }); assertObject(new char[] { 'a', '中', '无' }); assertObject(new Character[] { 'a', '中', '无' }); assertObject(new short[] { 37, 39, 12 }); assertObject(new Short[] { 37, 39, 12 }); assertObject(new int[] { 37, -39, 12456 }); assertObject(new Integer[] { 37, -39, 12456 }); assertObject(new long[] { 37L, -39L, 123456789L }); assertObject(new Long[] { 37L, -39L, 123456789L }); assertObject(new float[] { 37F, -3.14F, 123456.7F }); assertObject(new Float[] { 37F, -39F, 123456.7F }); assertObject(new double[] { 37D, -3.14D, 123456.7D }); assertObject(new Double[] { 37D, -39D, 123456.7D}); assertArrayObject(new Boolean[] { true, false, true }); assertArrayObject(new Byte[] { 1, 12, 28, 78 }); assertArrayObject(new Character[] { 'a', '中', '无' }); assertArrayObject(new Short[] { 37, 39, 12 }); assertArrayObject(new Integer[] { 37, -39, 12456 }); assertArrayObject(new Long[] { 37L, -39L, 123456789L }); assertArrayObject(new Float[] { 37F, -39F, 123456.7F }); assertArrayObject(new Double[] { 37D, -39D, 123456.7D}); } @Test public void test_PojoArray() throws Exception { Person[] array = new Person[2]; array[0] = new Person(); { Person person = new Person(); person.setName("xxxx"); array[1] = person; } assertArrayObject(array); } public List<Person> returnListPersonMethod() {return null;} public BigPerson returnBigPersonMethod() {return null;} public Type getType(String methodName){ Method method; try { method = getClass().getDeclaredMethod(methodName, new Class<?>[]{} ); } catch (Exception e) { throw new IllegalStateException(e); } Type gtype = method.getGenericReturnType(); return gtype; } @Test public void test_simpleCollection() throws Exception { Type gtype = getType("returnListPersonMethod"); List<Person> list = new ArrayList<Person>(); list.add(new Person()); { Person person = new Person(); person.setName("xxxx"); list.add(person); } assertObject(list,gtype); } BigPerson bigPerson; { bigPerson = new BigPerson(); bigPerson.setPersonId("id1"); bigPerson.setLoginName("name1"); bigPerson.setStatus(PersonStatus.ENABLED); bigPerson.setEmail("abc@123.com"); bigPerson.setPenName("pname"); ArrayList<Phone> phones = new ArrayList<Phone>(); Phone phone1 = new Phone("86", "0571", "11223344", "001"); Phone phone2 = new Phone("86", "0571", "11223344", "002"); phones.add(phone1); phones.add(phone2); PersonInfo pi = new PersonInfo(); pi.setPhones(phones); Phone fax = new Phone("86", "0571", "11223344", null); pi.setFax(fax); FullAddress addr = new FullAddress("CN", "zj", "1234", "Road1", "333444"); pi.setFullAddress(addr); pi.setMobileNo("1122334455"); pi.setMale(true); pi.setDepartment("b2b"); pi.setHomepageUrl("www.abc.com"); pi.setJobTitle("dev"); pi.setName("name2"); bigPerson.setInfoProfile(pi); } @Test public void test_total() throws Exception { Object generalize = PojoUtils.generalize(bigPerson); Type gtype = getType("returnBigPersonMethod"); Object realize = PojoUtils.realize(generalize, BigPerson.class,gtype); assertEquals(bigPerson, realize); } @Test public void test_total_Array() throws Exception { Object[] persons = new Object[] { bigPerson, bigPerson, bigPerson }; Object generalize = PojoUtils.generalize(persons); Object[] realize = (Object[]) PojoUtils.realize(generalize, Object[].class); assertArrayEquals(persons, realize); } // 循环测试 public static class Parent { String name; int age; Child child; public String gender; public String email; private String securityEmail; public void setEmail(String email) { this.securityEmail = email; } public String getEmail() { return this.securityEmail; } public static Parent getNewParent() { return new Parent(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Child getChild() { return child; } public void setChild(Child child) { this.child = child; } } public static class Child { String toy; public String gender; public int age; private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; } public String getToy() { return toy; } public void setToy(String toy) { this.toy = toy; } public Parent getParent() { return parent; } public void setParent(Parent parent) { this.parent = parent; } Parent parent; } @Test public void test_Loop_pojo() throws Exception { Parent p = new Parent(); p.setAge(10); p.setName("jerry"); Child c = new Child(); c.setToy("haha"); p.setChild(c); c.setParent(p); Object generalize = PojoUtils.generalize(p); Parent parent = (Parent) PojoUtils.realize(generalize, Parent.class); assertEquals(10, parent.getAge()); assertEquals("jerry", parent.getName()); assertEquals("haha", parent.getChild().getToy()); assertSame(parent, parent.getChild().getParent()); } @Test public void test_Loop_Map() throws Exception { Map<String, Object> map = new HashMap<String, Object>(); map.put("k", "v"); map.put("m", map); assertSame(map, map.get("m")); System.out.println(map); Object generalize = PojoUtils.generalize(map); System.out.println(generalize); @SuppressWarnings("unchecked") Map<String, Object> ret = (Map<String, Object>) PojoUtils.realize(generalize, Map.class); System.out.println(ret); assertEquals("v", ret.get("k")); assertSame(ret, ret.get("m")); } @Test public void test_LoopPojoInMap() throws Exception { Parent p = new Parent(); p.setAge(10); p.setName("jerry"); Child c = new Child(); c.setToy("haha"); p.setChild(c); c.setParent(p); Map<String, Object> map = new HashMap<String, Object>(); map.put("k", p); Object generalize = PojoUtils.generalize(map); @SuppressWarnings("unchecked") Map<String, Object> realize = (Map<String, Object>) PojoUtils.realize(generalize, Map.class, getType("getMapGenericType")); Parent parent = (Parent) realize.get("k"); assertEquals(10, parent.getAge()); assertEquals("jerry", parent.getName()); assertEquals("haha", parent.getChild().getToy()); assertSame(parent, parent.getChild().getParent()); } @Test public void test_LoopPojoInList() throws Exception { Parent p = new Parent(); p.setAge(10); p.setName("jerry"); Child c = new Child(); c.setToy("haha"); p.setChild(c); c.setParent(p); List<Object> list = new ArrayList<Object>(); list.add(p); Object generalize = PojoUtils.generalize(list); @SuppressWarnings("unchecked") List<Object> realize = (List<Object>) PojoUtils.realize(generalize, List.class, getType("getListGenericType")); Parent parent = (Parent) realize.get(0); assertEquals(10, parent.getAge()); assertEquals("jerry", parent.getName()); assertEquals("haha", parent.getChild().getToy()); assertSame(parent, parent.getChild().getParent()); } @Test public void test_PojoInList() throws Exception { Parent p = new Parent(); p.setAge(10); p.setName("jerry"); List<Object> list = new ArrayList<Object>(); list.add(p); Object generalize = PojoUtils.generalize(list); @SuppressWarnings("unchecked") List<Object> realize = (List<Object>) PojoUtils.realize(generalize, List.class, getType("getListGenericType")); Parent parent = (Parent) realize.get(0); assertEquals(10, parent.getAge()); assertEquals("jerry", parent.getName()); } public void setLong(long l){} public void setInt(int l){} public List<Parent> getListGenericType(){return null;}; public Map<String, Parent> getMapGenericType(){return null;}; // java.lang.IllegalArgumentException: argument type mismatch @Test public void test_realize_LongPararmter_IllegalArgumentException() throws Exception { Method method = PojoUtilsTest.class.getMethod("setLong", long.class); assertNotNull(method); Object value = PojoUtils.realize("563439743927993", method.getParameterTypes()[0], method.getGenericParameterTypes()[0]); method.invoke(new PojoUtilsTest(), value); } // java.lang.IllegalArgumentException: argument type mismatch @Test public void test_realize_IntPararmter_IllegalArgumentException() throws Exception { Method method = PojoUtilsTest.class.getMethod("setInt", int.class); assertNotNull(method); Object value = PojoUtils.realize("123", method.getParameterTypes()[0], method.getGenericParameterTypes()[0]); method.invoke(new PojoUtilsTest(), value); } @Test public void testStackOverflow() throws Exception { Parent parent = Parent.getNewParent(); parent.setAge(Integer.MAX_VALUE); String name = UUID.randomUUID().toString(); parent.setName(name); Object generalize = PojoUtils.generalize(parent); assertTrue(generalize instanceof Map); Map map = (Map) generalize; assertEquals(Integer.MAX_VALUE, map.get("age")); assertEquals(name, map.get("name")); Parent realize = (Parent)PojoUtils.realize(generalize, Parent.class); assertEquals(Integer.MAX_VALUE, realize.getAge()); assertEquals(name, realize.getName()); } @Test public void testGenerializeAndRealizeClass() throws Exception { Object generalize = PojoUtils.generalize(Integer.class); assertEquals(Integer.class.getName(), generalize); Object real = PojoUtils.realize(generalize, Integer.class.getClass()); assertEquals(Integer.class, real); generalize = PojoUtils.generalize(int[].class); assertEquals(int[].class.getName(), generalize); real = PojoUtils.realize(generalize, int[].class.getClass()); assertEquals(int[].class, real); } @Test public void testPublicField() throws Exception { Parent parent = new Parent(); parent.gender = "female"; parent.email = "email@host.com"; parent.setEmail("securityemail@host.com"); Child child = new Child(); parent.setChild(child); child.gender = "male"; child.setAge(20); child.setParent(parent); Object obj = PojoUtils.generalize(parent); Parent realizedParent = (Parent)PojoUtils.realize(obj, Parent.class); Assert.assertEquals(parent.gender, realizedParent.gender); Assert.assertEquals(child.gender, parent.getChild().gender); Assert.assertEquals(child.age, realizedParent.getChild().getAge()); Assert.assertEquals(parent.getEmail(), realizedParent.getEmail()); Assert.assertNull(realizedParent.email); } public static class TestData { private Map<String, Child> children = new HashMap<String, Child>(); private List<Child> list = new ArrayList<Child>(); public List<Child> getList() { return list; } public void setList(List<Child> list) { if (list != null && !list.isEmpty()) { this.list.addAll(list); } } public Map<String, Child> getChildren() { return children; } public void setChildren(Map<String, Child> children) { if (children!= null && !children.isEmpty()) { this.children.putAll(children); } } public void addChild(Child child) { this.children.put(child.getName(), child); } } @Test public void testMapField() throws Exception { TestData data = new TestData(); Child child = newChild("first", 1); data.addChild(child); child = newChild("second", 2); data.addChild(child); child = newChild("third", 3); data.addChild(child); data.setList(Arrays.asList(newChild("forth", 4))); Object obj = PojoUtils.generalize(data); Assert.assertEquals(3, data.getChildren().size()); Assert.assertTrue(data.getChildren().get("first").getClass() == Child.class); Assert.assertEquals(1, data.getList().size()); Assert.assertTrue(data.getList().get(0).getClass() == Child.class); TestData realizadData = (TestData) PojoUtils.realize(obj, TestData.class); Assert.assertEquals(data.getChildren().size(), realizadData.getChildren().size()); Assert.assertEquals(data.getChildren().keySet(), realizadData.getChildren().keySet()); for(Map.Entry<String, Child> entry : data.getChildren().entrySet()) { Child c = realizadData.getChildren().get(entry.getKey()); Assert.assertNotNull(c); Assert.assertEquals(entry.getValue().getName(), c.getName()); Assert.assertEquals(entry.getValue().getAge(), c.getAge()); } Assert.assertEquals(1, realizadData.getList().size()); Assert.assertEquals(data.getList().get(0).getName(), realizadData.getList().get(0).getName()); Assert.assertEquals(data.getList().get(0).getAge(), realizadData.getList().get(0).getAge()); } @Test public void testRealize() throws Exception { Map<String, String> inputMap = new LinkedHashMap<String, String>(); inputMap.put("key", "value"); Object obj = PojoUtils.generalize(inputMap); Assert.assertTrue(obj instanceof LinkedHashMap); Object outputObject = PojoUtils.realize(inputMap, LinkedHashMap.class); System.out.println(outputObject.getClass().getName()); Assert.assertTrue(outputObject instanceof LinkedHashMap); } @Test public void testRealizeLinkedList() throws Exception { LinkedList<Person> input = new LinkedList<Person>(); Person person = new Person(); person.setAge(37); input.add(person); Object obj = PojoUtils.generalize(input); Assert.assertTrue(obj instanceof List); Assert.assertTrue(input.get(0) instanceof Person); Object output = PojoUtils.realize(obj, LinkedList.class); Assert.assertTrue(output instanceof LinkedList); } @Test public void testPojoList() throws Exception { ListResult<Parent> result = new ListResult<Parent>(); List<Parent> list = new ArrayList<Parent>(); Parent parent = new Parent(); parent.setAge(Integer.MAX_VALUE); parent.setName("zhangsan"); list.add(parent); result.setResult(list); Object generializeObject = PojoUtils.generalize(result); Object realizeObject = PojoUtils.realize(generializeObject, ListResult.class); Assert.assertTrue(realizeObject instanceof ListResult); ListResult listResult = (ListResult)realizeObject; List l = listResult.getResult(); Assert.assertTrue(l.size() == 1); Assert.assertTrue(l.get(0) instanceof Parent); Parent realizeParent = (Parent)l.get(0); Assert.assertEquals(parent.getName(), realizeParent.getName()); Assert.assertEquals(parent.getAge(), realizeParent.getAge()); } @Test public void testListPojoListPojo() throws Exception { InnerPojo<Parent> parentList = new InnerPojo<Parent>(); Parent parent = new Parent(); parent.setName("zhangsan"); parent.setAge(Integer.MAX_VALUE); parentList.setList(Arrays.asList(parent)); ListResult<InnerPojo<Parent>> list = new ListResult<InnerPojo<Parent>>(); list.setResult(Arrays.asList(parentList)); Object generializeObject = PojoUtils.generalize(list); Object realizeObject = PojoUtils.realize(generializeObject, ListResult.class); Assert.assertTrue(realizeObject instanceof ListResult); ListResult realizeList = (ListResult)realizeObject; List realizeInnerList = realizeList.getResult(); Assert.assertEquals(1, realizeInnerList.size()); Assert.assertTrue(realizeInnerList.get(0) instanceof InnerPojo); InnerPojo realizeParentList = (InnerPojo)realizeInnerList.get(0); Assert.assertEquals(1, realizeParentList.getList().size()); Assert.assertTrue(realizeParentList.getList().get(0) instanceof Parent); Parent realizeParent = (Parent)realizeParentList.getList().get(0); Assert.assertEquals(parent.getName(), realizeParent.getName()); Assert.assertEquals(parent.getAge(), realizeParent.getAge()); } public static class InnerPojo<T> { private List<T> list; public List<T> getList() { return list; } public void setList(List<T> list) { this.list = list; } } public static class ListResult<T> { List<T> result; public List<T> getResult() { return result; } public void setResult(List<T> result) { this.result = result; } } private static Child newChild(String name, int age) { Child result = new Child(); result.setName(name); result.setAge(age); return result; } }