| /* | |
| * Copyright 2010 Google Inc. | |
| * | |
| * 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.google.web.bindery.autobean.shared; | |
| import com.google.gwt.core.client.GWT; | |
| import com.google.gwt.junit.client.GWTTestCase; | |
| import com.google.web.bindery.autobean.shared.AutoBean.PropertyName; | |
| import com.google.web.bindery.autobean.shared.impl.EnumMap; | |
| import java.util.Arrays; | |
| import java.util.Collections; | |
| import java.util.Date; | |
| import java.util.HashMap; | |
| import java.util.List; | |
| import java.util.Map; | |
| /** | |
| * Simple encoding / decoding tests for the AutoBeanCodex. | |
| */ | |
| public class AutoBeanCodexTest extends GWTTestCase { | |
| /** | |
| * Protected so that the JRE-only test can instantiate instances. | |
| */ | |
| protected interface Factory extends AutoBeanFactory { | |
| AutoBean<HasSplittable> hasAutoBean(); | |
| AutoBean<HasCycle> hasCycle(); | |
| AutoBean<HasDate> hasDate(); | |
| AutoBean<HasEnum> hasEnum(); | |
| AutoBean<HasList> hasList(); | |
| AutoBean<HasLong> hasLong(); | |
| AutoBean<HasMap> hasMap(); | |
| AutoBean<HasSimple> hasSimple(); | |
| AutoBean<Simple> simple(); | |
| } | |
| /* | |
| * These enums are used to verify that a List<Enum> or Map<Enum, Enum> pulls | |
| * in the necessary metadata. | |
| */ | |
| enum EnumReachableThroughList { | |
| FOO_LIST | |
| } | |
| enum EnumReachableThroughMapKey { | |
| FOO_KEY | |
| } | |
| enum EnumReachableThroughMapValue { | |
| FOO_VALUE | |
| } | |
| /** | |
| * Used to test that cycles are detected. | |
| */ | |
| interface HasCycle { | |
| List<HasCycle> getCycle(); | |
| void setCycle(List<HasCycle> cycle); | |
| } | |
| interface HasDate { | |
| Date getDate(); | |
| void setDate(Date date); | |
| } | |
| interface HasEnum { | |
| MyEnum getEnum(); | |
| List<MyEnum> getEnums(); | |
| Map<MyEnum, Integer> getMap(); | |
| List<EnumReachableThroughList> getParameterizedList(); | |
| Map<EnumReachableThroughMapKey, EnumReachableThroughMapValue> getParameterizedMap(); | |
| void setEnum(MyEnum value); | |
| void setEnums(List<MyEnum> value); | |
| void setMap(Map<MyEnum, Integer> value); | |
| } | |
| interface HasList { | |
| List<Integer> getIntList(); | |
| List<Simple> getList(); | |
| void setIntList(List<Integer> list); | |
| void setList(List<Simple> list); | |
| } | |
| interface HasLong { | |
| long getLong(); | |
| void setLong(long l); | |
| } | |
| interface HasMap { | |
| Map<Simple, Simple> getComplexMap(); | |
| Map<Map<String, String>, Map<String, String>> getNestedMap(); | |
| Map<String, Simple> getSimpleMap(); | |
| void setComplexMap(Map<Simple, Simple> map); | |
| void setNestedMap(Map<Map<String, String>, Map<String, String>> map); | |
| void setSimpleMap(Map<String, Simple> map); | |
| } | |
| interface HasSimple { | |
| Simple getSimple(); | |
| void setSimple(Simple s); | |
| } | |
| interface HasSplittable { | |
| Splittable getSimple(); | |
| List<Splittable> getSimpleList(); | |
| Map<Splittable, Splittable> getSplittableMap(); | |
| Splittable getString(); | |
| void setSimple(Splittable simple); | |
| void setSimpleList(List<Splittable> simple); | |
| void setSplittableMap(Map<Splittable, Splittable> map); | |
| void setString(Splittable s); | |
| } | |
| enum MyEnum { | |
| FOO, | |
| /** | |
| * Contains a method that cannot even be called, but is enough to make | |
| * MyEnum.BAR.getClass().isEnum()==false, because BAR's class is now an | |
| * anonymous subclass of MyEnum. | |
| */ | |
| BAR { | |
| @SuppressWarnings("unused") | |
| private void dummy() { | |
| } | |
| }, | |
| // The eclipse formatter wants to put this annotation inline | |
| @PropertyName("quux") | |
| BAZ; | |
| } | |
| interface ReachableOnlyFromParameterization extends Simple { | |
| } | |
| interface Simple { | |
| int getInt(); | |
| String getString(); | |
| Boolean hasOtherBoolean(); | |
| boolean isBoolean(); | |
| void setBoolean(boolean b); | |
| void setInt(int i); | |
| void setOtherBoolean(Boolean b); | |
| void setString(String s); | |
| } | |
| @SuppressWarnings("deprecation") | |
| private static final Date[] DATES = { | |
| new Date(1900, 0, 1), new Date(2012, 3, 10), new Date(2100, 11, 31), | |
| new Date(-8640000000000000L), // lowest JavaScript Date value | |
| new Date(8640000000000000L) // highest JavaScript Date value | |
| }; | |
| protected Factory f; | |
| @Override | |
| public String getModuleName() { | |
| return "com.google.web.bindery.autobean.AutoBean"; | |
| } | |
| public void testCycle() { | |
| AutoBean<HasCycle> bean = f.hasCycle(); | |
| bean.as().setCycle(Arrays.asList(bean.as())); | |
| try { | |
| checkEncode(bean); | |
| fail("Should not have encoded"); | |
| } catch (UnsupportedOperationException expected) { | |
| } | |
| } | |
| public void testDate() { | |
| for (Date d : DATES) { | |
| AutoBean<HasDate> bean = f.hasDate(); | |
| bean.as().setDate(d); | |
| AutoBean<HasDate> decodedBean = checkEncode(bean); | |
| assertEquals(d, decodedBean.as().getDate()); | |
| } | |
| } | |
| /** | |
| * See issue 6331. | |
| */ | |
| public void testDecodeDateFromNumericTimestamp() { | |
| for (Date d : DATES) { | |
| AutoBean<HasDate> decodedBean = | |
| AutoBeanCodex.decode(f, HasDate.class, "{\"date\": " + d.getTime() + "}"); | |
| assertEquals(d, decodedBean.as().getDate()); | |
| } | |
| } | |
| /** | |
| * See issue 6636. | |
| */ | |
| public void testDecodeLongFromNumericValue() { | |
| final long[] longs = { 42L, | |
| -9007199254740991L, // lowest integral value that can be represented by a JavaScript Number | |
| 9007199254740991L // highest integral value that van be represented by a JavaScript Number | |
| }; | |
| for (long l : longs) { | |
| AutoBean<HasLong> decodedBean = AutoBeanCodex.decode(f, HasLong.class, "{\"long\": " + l + "}"); | |
| assertEquals(l, decodedBean.as().getLong()); | |
| } | |
| } | |
| public void testEmptyList() { | |
| AutoBean<HasList> bean = f.hasList(); | |
| bean.as().setList(Collections.<Simple> emptyList()); | |
| AutoBean<HasList> decodedBean = checkEncode(bean); | |
| assertNotNull(decodedBean.as().getList()); | |
| assertTrue(decodedBean.as().getList().isEmpty()); | |
| } | |
| public void testEnum() { | |
| EnumMap map = (EnumMap) f; | |
| assertEquals("BAR", map.getToken(MyEnum.BAR)); | |
| assertEquals("quux", map.getToken(MyEnum.BAZ)); | |
| assertEquals(MyEnum.BAR, map.getEnum(MyEnum.class, "BAR")); | |
| assertEquals(MyEnum.BAZ, map.getEnum(MyEnum.class, "quux")); | |
| List<MyEnum> arrayValue = Arrays.asList(MyEnum.FOO, MyEnum.BAR, null, MyEnum.BAZ); | |
| Map<MyEnum, Integer> mapValue = new HashMap<MyEnum, Integer>(); | |
| mapValue.put(MyEnum.FOO, 0); | |
| mapValue.put(MyEnum.BAR, 1); | |
| mapValue.put(MyEnum.BAZ, 2); | |
| AutoBean<HasEnum> bean = f.hasEnum(); | |
| bean.as().setEnum(MyEnum.BAZ); | |
| bean.as().setEnums(arrayValue); | |
| bean.as().setMap(mapValue); | |
| Splittable split = AutoBeanCodex.encode(bean); | |
| // Make sure the overridden form is always used | |
| assertFalse(split.getPayload().contains("BAZ")); | |
| AutoBean<HasEnum> decoded = checkEncode(bean); | |
| assertEquals(MyEnum.BAZ, decoded.as().getEnum()); | |
| assertEquals(arrayValue, decoded.as().getEnums()); | |
| assertEquals(mapValue, decoded.as().getMap()); | |
| assertEquals(MyEnum.BAZ, AutoBeanUtils.getAllProperties(bean).get("enum")); | |
| bean.as().setEnum(null); | |
| assertNull(bean.as().getEnum()); | |
| assertNull(AutoBeanUtils.getAllProperties(bean).get("enum")); | |
| decoded = checkEncode(bean); | |
| assertNull(decoded.as().getEnum()); | |
| } | |
| /** | |
| * Ensures that enum types that are reachable only through a method | |
| * parameterization are included in the enum map. | |
| */ | |
| public void testEnumReachableOnlyThroughParameterization() { | |
| EnumMap map = (EnumMap) f; | |
| assertEquals("FOO_LIST", map.getToken(EnumReachableThroughList.FOO_LIST)); | |
| assertEquals("FOO_KEY", map.getToken(EnumReachableThroughMapKey.FOO_KEY)); | |
| assertEquals("FOO_VALUE", map.getToken(EnumReachableThroughMapValue.FOO_VALUE)); | |
| assertEquals(EnumReachableThroughList.FOO_LIST, map.getEnum(EnumReachableThroughList.class, | |
| "FOO_LIST")); | |
| assertEquals(EnumReachableThroughMapKey.FOO_KEY, map.getEnum(EnumReachableThroughMapKey.class, | |
| "FOO_KEY")); | |
| assertEquals(EnumReachableThroughMapValue.FOO_VALUE, map.getEnum( | |
| EnumReachableThroughMapValue.class, "FOO_VALUE")); | |
| } | |
| public void testLong() { | |
| long[] longs = { Long.MIN_VALUE + 1, // See issue 7308 | |
| 42L, Long.MAX_VALUE }; | |
| for (long l : longs) { | |
| AutoBean<HasLong> bean = f.hasLong(); | |
| bean.as().setLong(l); | |
| AutoBean<HasLong> decodedBean = checkEncode(bean); | |
| assertEquals(l, decodedBean.as().getLong()); | |
| } | |
| } | |
| public void testMap() { | |
| AutoBean<HasMap> bean = f.hasMap(); | |
| Map<String, Simple> map = new HashMap<String, Simple>(); | |
| Map<Simple, Simple> complex = new HashMap<Simple, Simple>(); | |
| bean.as().setSimpleMap(map); | |
| bean.as().setComplexMap(complex); | |
| for (int i = 0, j = 5; i < j; i++) { | |
| Simple s = f.simple().as(); | |
| s.setInt(i); | |
| map.put(String.valueOf(i), s); | |
| Simple key = f.simple().as(); | |
| key.setString(String.valueOf(i)); | |
| complex.put(key, s); | |
| } | |
| AutoBean<HasMap> decoded = checkEncode(bean); | |
| map = decoded.as().getSimpleMap(); | |
| complex = decoded.as().getComplexMap(); | |
| assertEquals(5, map.size()); | |
| for (int i = 0, j = 5; i < j; i++) { | |
| Simple s = map.get(String.valueOf(i)); | |
| assertNotNull(s); | |
| assertEquals(i, s.getInt()); | |
| } | |
| assertEquals(5, complex.size()); | |
| for (Map.Entry<Simple, Simple> entry : complex.entrySet()) { | |
| assertEquals(entry.getKey().getString(), String.valueOf(entry.getValue().getInt())); | |
| } | |
| } | |
| /** | |
| * Verify that arbitrarily complicated Maps of Maps work. | |
| */ | |
| public void testNestedMap() { | |
| Map<String, String> key = new HashMap<String, String>(); | |
| key.put("a", "b"); | |
| Map<String, String> value = new HashMap<String, String>(); | |
| value.put("c", "d"); | |
| Map<Map<String, String>, Map<String, String>> test = | |
| new HashMap<Map<String, String>, Map<String, String>>(); | |
| test.put(key, value); | |
| AutoBean<HasMap> bean = f.hasMap(); | |
| bean.as().setNestedMap(test); | |
| AutoBean<HasMap> decoded = checkEncode(bean); | |
| assertEquals(1, decoded.as().getNestedMap().size()); | |
| } | |
| public void testNull() { | |
| AutoBean<Simple> bean = f.simple(); | |
| AutoBean<Simple> decodedBean = checkEncode(bean); | |
| assertNull(decodedBean.as().getString()); | |
| } | |
| public void testSimple() { | |
| AutoBean<Simple> bean = f.simple(); | |
| Simple simple = bean.as(); | |
| simple.setBoolean(true); | |
| simple.setInt(42); | |
| simple.setOtherBoolean(true); | |
| simple.setString("Hello World!"); | |
| AutoBean<Simple> decodedBean = checkEncode(bean); | |
| assertTrue(AutoBeanUtils.diff(bean, decodedBean).isEmpty()); | |
| assertTrue(decodedBean.as().isBoolean()); | |
| assertTrue(decodedBean.as().hasOtherBoolean()); | |
| AutoBean<HasSimple> bean2 = f.hasSimple(); | |
| bean2.as().setSimple(simple); | |
| AutoBean<HasSimple> decodedBean2 = checkEncode(bean2); | |
| assertNotNull(decodedBean2.as().getSimple()); | |
| assertTrue(AutoBeanUtils.diff(bean, AutoBeanUtils.getAutoBean(decodedBean2.as().getSimple())) | |
| .isEmpty()); | |
| AutoBean<HasList> bean3 = f.hasList(); | |
| bean3.as().setIntList(Arrays.asList(1, 2, 3, null, 4, 5)); | |
| bean3.as().setList(Arrays.asList(simple)); | |
| AutoBean<HasList> decodedBean3 = checkEncode(bean3); | |
| assertNotNull(decodedBean3.as().getIntList()); | |
| assertEquals(Arrays.asList(1, 2, 3, null, 4, 5), decodedBean3.as().getIntList()); | |
| assertNotNull(decodedBean3.as().getList()); | |
| assertEquals(1, decodedBean3.as().getList().size()); | |
| assertTrue(AutoBeanUtils.diff(bean, | |
| AutoBeanUtils.getAutoBean(decodedBean3.as().getList().get(0))).isEmpty()); | |
| } | |
| public void testSplittable() { | |
| AutoBean<Simple> simple = f.simple(); | |
| simple.as().setString("Simple"); | |
| AutoBean<HasSplittable> bean = f.hasAutoBean(); | |
| bean.as().setSimple(AutoBeanCodex.encode(simple)); | |
| bean.as().setString(ValueCodex.encode("Hello ['\"] world")); | |
| List<Splittable> testList = | |
| Arrays.asList(AutoBeanCodex.encode(simple), null, AutoBeanCodex.encode(simple)); | |
| bean.as().setSimpleList(testList); | |
| Map<Splittable, Splittable> testMap = | |
| Collections.singletonMap(ValueCodex.encode("12345"), ValueCodex.encode("5678")); | |
| bean.as().setSplittableMap(testMap); | |
| AutoBean<HasSplittable> decoded = checkEncode(bean); | |
| Splittable toDecode = decoded.as().getSimple(); | |
| AutoBean<Simple> decodedSimple = AutoBeanCodex.decode(f, Simple.class, toDecode); | |
| assertEquals("Simple", decodedSimple.as().getString()); | |
| assertEquals("Hello ['\"] world", ValueCodex.decode(String.class, decoded.as().getString())); | |
| assertEquals("12345", decoded.as().getSplittableMap().keySet().iterator().next().asString()); | |
| assertEquals("5678", decoded.as().getSplittableMap().values().iterator().next().asString()); | |
| List<Splittable> list = decoded.as().getSimpleList(); | |
| assertEquals(3, list.size()); | |
| assertNull(list.get(1)); | |
| assertEquals("Simple", AutoBeanCodex.decode(f, Simple.class, list.get(2)).as().getString()); | |
| } | |
| @Override | |
| protected void gwtSetUp() throws Exception { | |
| f = GWT.create(Factory.class); | |
| } | |
| private <T> AutoBean<T> checkEncode(AutoBean<T> bean) { | |
| Splittable split = AutoBeanCodex.encode(bean); | |
| AutoBean<T> decoded = AutoBeanCodex.decode(f, bean.getType(), split); | |
| assertTrue(AutoBeanUtils.deepEquals(bean, decoded)); | |
| return decoded; | |
| } | |
| } |