MapperTest.java

/*
 * Copyright 2017 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.firebase.database;

import static com.google.firebase.database.TestHelpers.fromSingleQuotedString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;

import com.google.firebase.database.utilities.encoding.CustomClassMapper;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.junit.Test;

public class MapperTest {

  private static final double EPSILON = 0.00001f;

  private static <T> T deserialize(String jsonString, Class<T> clazz) {
    Map<String, Object> json = fromSingleQuotedString(jsonString);
    return CustomClassMapper.convertToCustomClass(json, clazz);
  }

  private static <T> T deserialize(String jsonString, GenericTypeIndicator<T> typeIndicator) {
    Map<String, Object> json = fromSingleQuotedString(jsonString);
    return CustomClassMapper.convertToCustomClass(json, typeIndicator);
  }

  private static Object serialize(Object object) {
    return CustomClassMapper.convertToPlainJavaTypes(object);
  }

  private static void assertJson(String expected, Object actual) {
    assertEquals(fromSingleQuotedString(expected), actual);
  }

  @Test
  public void primitiveDeserializeString() {
    StringBean bean = deserialize("{'value': 'foo'}", StringBean.class);
    assertEquals("foo", bean.value);

    // Double
    try {
      deserialize("{'value': 1.1}", StringBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // Int
    try {
      deserialize("{'value': 1}", StringBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // Long
    try {
      deserialize("{'value': 1234567890123}", StringBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // Boolean
    try {
      deserialize("{'value': true}", StringBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }
  }

  @Test
  public void primitiveDeserializeBoolean() {
    BooleanBean beanBoolean = deserialize("{'value': true}", BooleanBean.class);
    assertEquals(true, beanBoolean.value);

    // Double
    try {
      deserialize("{'value': 1.1}", BooleanBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // Long
    try {
      deserialize("{'value': 1234567890123}", BooleanBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // Int
    try {
      deserialize("{'value': 1}", BooleanBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // String
    try {
      deserialize("{'value': 'foo'}", BooleanBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }
  }

  @Test
  public void primitiveDeserializeDouble() {
    DoubleBean beanDouble = deserialize("{'value': 1.1}", DoubleBean.class);
    assertEquals(1.1, beanDouble.value, EPSILON);

    // Int
    DoubleBean beanInt = deserialize("{'value': 1}", DoubleBean.class);
    assertEquals(1, beanInt.value, EPSILON);
    // Long
    DoubleBean beanLong = deserialize("{'value': 1234567890123}", DoubleBean.class);
    assertEquals(1234567890123L, beanLong.value, EPSILON);

    // Boolean
    try {
      deserialize("{'value': true}", DoubleBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // String
    try {
      deserialize("{'value': 'foo'}", DoubleBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }
  }

  @Test
  public void primitiveDeserializeFloat() {
    FloatBean beanFloat = deserialize("{'value': 1.1}", FloatBean.class);
    assertEquals(1.1, beanFloat.value, EPSILON);

    // Int
    FloatBean beanInt = deserialize("{'value': 1}", FloatBean.class);
    assertEquals(1, beanInt.value, EPSILON);
    // Long
    FloatBean beanLong = deserialize("{'value': 1234567890123}", FloatBean.class);
    assertEquals(Long.valueOf(1234567890123L).floatValue(), beanLong.value, EPSILON);

    // Boolean
    try {
      deserialize("{'value': true}", FloatBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // String
    try {
      deserialize("{'value': 'foo'}", FloatBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }
  }

  @Test
  public void primitiveDeserializeInt() {
    IntBean beanInt = deserialize("{'value': 1}", IntBean.class);
    assertEquals(1, beanInt.value);

    // Double
    IntBean beanDouble = deserialize("{'value': 1.1}", IntBean.class);
    assertEquals(1, beanDouble.value);

    // Large doubles
    try {
      deserialize("{'value': 1e10}", IntBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // Long
    try {
      deserialize("{'value': 1234567890123}", IntBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // Boolean
    try {
      deserialize("{'value': true}", IntBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // String
    try {
      deserialize("{'value': 'foo'}", IntBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }
  }

  @Test
  public void primitiveDeserializeLong() {
    LongBean beanLong = deserialize("{'value': 1234567890123}", LongBean.class);
    assertEquals(1234567890123L, beanLong.value);

    //Int
    LongBean beanInt = deserialize("{'value': 1}", LongBean.class);
    assertEquals(1, beanInt.value);

    // Double
    LongBean beanDouble = deserialize("{'value': 1.1}", LongBean.class);
    assertEquals(1, beanDouble.value);

    // Large doubles
    try {
      deserialize("{'value': 1e300}", LongBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // Boolean
    try {
      deserialize("{'value': true}", LongBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }

    // String
    try {
      deserialize("{'value': 'foo'}", LongBean.class);
      fail("Should throw");
    } catch (DatabaseException e) { // ignore
    }
  }

  @Test(expected = DatabaseException.class)
  public void primitiveDeserializeWrongTypeMap() {
    deserialize("{'value': {'foo': 'bar'}}", StringBean.class);
  }

  @Test(expected = DatabaseException.class)
  public void primitiveDeserializeWrongTypeList() {
    deserialize("{'value': ['foo']}", StringBean.class);
  }

  @Test
  public void publicFieldDeserialze() {
    PublicFieldBean bean = deserialize("{'value': 'foo'}", PublicFieldBean.class);
    assertEquals("foo", bean.value);
  }

  @Test
  public void publicPrivateFieldDeserialze() {
    PublicPrivateFieldBean bean =
        deserialize(
            "{'value1': 'foo', 'value2': 'bar', 'value3': 'baz'}", PublicPrivateFieldBean.class);
    assertEquals("foo", bean.value1);
    assertEquals(null, bean.value2);
    assertEquals(null, bean.value3);
  }

  @Test(expected = DatabaseException.class)
  public void packageFieldDeserialze() {
    deserialize("{'value': 'foo'}", PackageFieldBean.class);
  }

  @Test(expected = DatabaseException.class)
  public void privateFieldDeserialize() {
    deserialize("{'value': 'foo'}", PrivateFieldBean.class);
  }

  @Test
  public void packageGetterDeserialize() {
    PackageGetterBean bean =
        deserialize("{'publicValue': 'foo', 'packageValue': 'bar'}", PackageGetterBean.class);
    assertEquals("foo", bean.publicValue);
    assertNull(bean.packageValue);
  }

  @Test
  public void packageGetterSerialize() {
    PackageGetterBean bean = new PackageGetterBean();
    bean.packageValue = "foo";
    bean.publicValue = "bar";
    assertJson("{'publicValue': 'bar'}", serialize(bean));
  }

  @Test
  public void ignoreExtraProperties() {
    PublicFieldBean bean = deserialize("{'value': 'foo', 'unknown': 'bar'}", PublicFieldBean.class);
    assertEquals("foo", bean.value);
  }

  @Test(expected = DatabaseException.class)
  public void throwOnUnknownProperties() {
    deserialize("{'value': 'foo', 'unknown': 'bar'}", ThrowOnUnknownPropertiesBean.class);
  }

  @Test(expected = DatabaseException.class)
  public void twoSetterBean() {
    deserialize("{'value': 'foo'}", TwoSetterBean.class);
  }

  @Test
  public void testXmlAndUrlBean() {
    XMLAndURLBean bean =
        deserialize("{'xmlandURL1': 'foo', 'XMLAndURL2': 'bar'}", XMLAndURLBean.class);
    assertEquals("foo", bean.XMLAndURL1);
    assertEquals("bar", bean.XMLAndURL2);
  }

  @Test
  public void setterIsCalledWhenPresent() {
    SetterBean bean = deserialize("{'value': 'foo'}", SetterBean.class);
    assertEquals("setter:foo", bean.value);
  }

  @Test
  public void privateSetterIsCalledWhenPresent() {
    PrivateSetterBean bean = deserialize("{'value': 'foo'}", PrivateSetterBean.class);
    assertEquals("setter:foo", bean.value);
  }

  @Test(expected = DatabaseException.class)
  public void setterIsCaseSensitive1() {
    deserialize("{'value': 'foo'}", CaseSensitiveSetterBean1.class);
  }

  @Test(expected = DatabaseException.class)
  public void setterIsCaseSensitive2() {
    deserialize("{'value': 'foo'}", CaseSensitiveSetterBean2.class);
  }

  @Test
  public void caseSensitiveSetterIsCalledWhenPresent1() {
    CaseSensitiveSetterBean3 bean = deserialize("{'value': 'foo'}", CaseSensitiveSetterBean3.class);
    assertEquals("setter:foo", bean.value);
  }

  @Test
  public void caseSensitiveSetterIsCalledWhenPresent2() {
    CaseSensitiveSetterBean4 bean = deserialize("{'value': 'foo'}", CaseSensitiveSetterBean4.class);
    assertEquals("setter:foo", bean.value);
  }

  @Test
  public void caseSensitiveSetterIsCalledWhenPresent3() {
    CaseSensitiveSetterBean5 bean = deserialize("{'value': 'foo'}", CaseSensitiveSetterBean5.class);
    assertEquals("foo", bean.value);
  }

  @Test(expected = DatabaseException.class)
  public void caseSensitiveSetterMustHaveSameCaseAsSetter() {
    deserialize("{'value': 'foo'}", CaseSensitiveSetterBean6.class);
  }

  @Test
  public void wrongSetterIsNotCalledWhenPresent() {
    WrongSetterBean bean = deserialize("{'value': 'foo'}", WrongSetterBean.class);
    assertEquals("foo", bean.value);
  }

  @Test
  public void recursiveParsingWorks() {
    RecursiveBean bean = deserialize("{'bean': {'value': 'foo'}}", RecursiveBean.class);
    assertEquals("foo", bean.bean.value);
  }

  @Test
  public void beansCanContainLists() {
    ListBean bean = deserialize("{'values': ['foo', 'bar']}", ListBean.class);
    assertEquals(Arrays.asList("foo", "bar"), bean.values);
  }

  @Test
  public void beansCanContainMaps() {
    MapBean bean = deserialize("{'values': {'foo': 'bar'}}", MapBean.class);
    Map<String, Object> expected = fromSingleQuotedString("{'foo': 'bar'}");
    assertEquals(expected, bean.values);
  }

  @Test
  public void beansCanContainBeanLists() {
    RecursiveListBean bean = deserialize("{'values': [{'value': 'foo'}]}", RecursiveListBean.class);
    assertEquals(1, bean.values.size());
    assertEquals("foo", bean.values.get(0).value);
  }

  @Test
  public void beansCanContainBeanMaps() {
    RecursiveMapBean bean =
        deserialize("{'values': {'key': {'value': 'foo'}}}", RecursiveMapBean.class);
    assertEquals(1, bean.values.size());
    assertEquals("foo", bean.values.get("key").value);
  }

  @Test(expected = DatabaseException.class)
  public void beanMapsMustHaveStringKeys() {
    deserialize("{'values': {'1': 'bar'}}", IllegalKeyMapBean.class);
  }

  @Test
  public void serializeStringBean() {
    StringBean bean = new StringBean();
    bean.value = "foo";
    assertJson("{'value': 'foo'}", serialize(bean));
  }

  @Test
  public void serializeDoubleBean() {
    DoubleBean bean = new DoubleBean();
    bean.value = 1.1;
    assertJson("{'value': 1.1}", serialize(bean));
  }

  @Test
  public void serializeDoubleBeanAsLong() {
    DoubleBean bean = new DoubleBean();
    bean.value = 1234567890123L;
    assertJson("{'value': 1234567890123}", serialize(bean));

    bean.value = 1234567890123.0;
    assertJson("{'value': 1234567890123}", serialize(bean));
  }

  @Test
  public void serializeIntBean() {
    IntBean bean = new IntBean();
    bean.value = 1;
    assertJson("{'value': 1}", serialize(bean));
  }

  @Test
  public void serializeLongBean() {
    LongBean bean = new LongBean();
    bean.value = 1234567890123L;
    assertJson("{'value': 1234567890123}", serialize(bean));
  }

  @Test
  public void serializeBooleanBean() {
    BooleanBean bean = new BooleanBean();
    bean.value = true;
    assertJson("{'value': true}", serialize(bean));
  }

  @Test
  public void serializeFloatBean() {
    FloatBean bean = new FloatBean();
    bean.value = 0.5f;
    assertJson("{'value': 0.5}", serialize(bean));
  }

  @Test
  public void serializePublicFieldBean() {
    PublicFieldBean bean = new PublicFieldBean();
    bean.value = "foo";
    assertJson("{'value': 'foo'}", serialize(bean));
  }

  @Test(expected = DatabaseException.class)
  public void serializePrivateFieldBean() {
    PrivateFieldBean bean = new PrivateFieldBean();
    bean.value = "foo";
    serialize(bean);
  }

  @Test(expected = DatabaseException.class)
  public void serializePackageFieldBean() {
    PackageFieldBean bean = new PackageFieldBean();
    bean.value = "foo";
    serialize(bean);
  }

  @Test
  public void serializePublicPrivateFieldBean() {
    PublicPrivateFieldBean bean = new PublicPrivateFieldBean();
    bean.value1 = "foo";
    bean.value2 = "bar";
    bean.value3 = "baz";
    assertJson("{'value1': 'foo'}", serialize(bean));
  }

  @Test
  public void getterOverridesField() {
    GetterBean bean = new GetterBean();
    bean.value = "foo";
    assertJson("{'value': 'getter:foo'}", serialize(bean));
  }

  @Test
  public void getterOverridesPublicField() {
    GetterPublicFieldBean bean = new GetterPublicFieldBean();
    bean.value = "foo";
    assertJson("{'value': 'getter:foo'}", serialize(bean));
  }

  @Test(expected = DatabaseException.class)
  public void getterAndPublicFieldsConflictOnCaseSensitivity() {
    GetterPublicFieldBeanCaseSensitive bean = new GetterPublicFieldBeanCaseSensitive();
    bean.valueCase = "foo";
    serialize(bean);
  }

  @Test
  public void caseSensitveGetterBean1() {
    CaseSensitiveGetterBean1 bean = new CaseSensitiveGetterBean1();
    bean.value = "foo";
    assertJson("{'value': 'foo'}", serialize(bean));
  }

  @Test
  public void caseSensitveGetterBean2() {
    CaseSensitiveGetterBean2 bean = new CaseSensitiveGetterBean2();
    bean.value = "foo";
    assertJson("{'value': 'foo'}", serialize(bean));
  }

  @Test
  public void caseSensitveGetterBean3() {
    CaseSensitiveGetterBean3 bean = new CaseSensitiveGetterBean3();
    bean.value = "foo";
    assertJson("{'value': 'foo'}", serialize(bean));
  }

  @Test
  public void caseSensitveGetterBean4() {
    CaseSensitiveGetterBean4 bean = new CaseSensitiveGetterBean4();
    bean.value = "foo";
    assertJson("{'vaLUE': 'foo'}", serialize(bean));
  }

  @Test
  public void recursiveSerializingWorks() {
    RecursiveBean bean = new RecursiveBean();
    bean.bean = new StringBean();
    bean.bean.value = "foo";
    assertJson("{'bean': {'value': 'foo'}}", serialize(bean));
  }

  @Test
  public void serializingListsWorks() {
    ListBean bean = new ListBean();
    bean.values = Arrays.asList("foo", "bar");
    assertJson("{'values': ['foo', 'bar']}", serialize(bean));
  }

  @Test
  public void serializingMapsWorks() {
    MapBean bean = new MapBean();
    bean.values =
        new HashMap<String, String>() {
          {
            put("foo", "bar");
          }
        };
    assertJson("{'values': {'foo': 'bar'}}", serialize(bean));
  }

  @Test
  public void serializeListOfBeansWorks() {
    RecursiveListBean bean = new RecursiveListBean();
    bean.values =
        new ArrayList<StringBean>() {
          {
            StringBean bean = new StringBean();
            bean.value = "foo";
            add(bean);
          }
        };
    assertJson("{'values': [{'value': 'foo'}]}", serialize(bean));
  }

  @Test
  public void serializeMapOfBeansWorks() {
    RecursiveMapBean bean = new RecursiveMapBean();
    bean.values =
        new HashMap<String, StringBean>() {
          {
            StringBean bean = new StringBean();
            bean.value = "foo";
            put("key", bean);
          }
        };
    assertJson("{'values': {'key': {'value': 'foo'}}}", serialize(bean));
  }

  @Test(expected = DatabaseException.class)
  public void beanMapsMustHaveStringKeysForSerializing() {
    IllegalKeyMapBean bean = new IllegalKeyMapBean();
    bean.values =
        new HashMap<Integer, StringBean>() {
          {
            StringBean bean = new StringBean();
            bean.value = "foo";
            put(1, bean);
          }
        };
    serialize(bean);
  }

  @Test(expected = DatabaseException.class)
  public void twoGettersThrows() {
    TwoGetterBean bean = new TwoGetterBean();
    bean.value = "foo";
    serialize(bean);
  }

  @Test
  public void serializeUpperCase() {
    XMLAndURLBean bean = new XMLAndURLBean();
    bean.XMLAndURL1 = "foo";
    bean.XMLAndURL2 = "bar";
    assertJson("{'xmlandURL1': 'foo', 'XMLAndURL2': 'bar'}", serialize(bean));
  }

  @Test
  public void onlySerializesGetterWithCorrectArguments() {
    GetterArgumentsBean bean = new GetterArgumentsBean();
    bean.value = "foo";
    assertJson("{'value1': 'foo1', 'value4': 'foo4'}", serialize(bean));
  }

  @Test
  public void roundTripCaseSensitiveFieldBean1() {
    CaseSensitiveFieldBean1 bean = new CaseSensitiveFieldBean1();
    bean.VALUE = "foo";
    assertJson("{'VALUE': 'foo'}", serialize(bean));
    CaseSensitiveFieldBean1 deserialized =
        deserialize("{'VALUE': 'foo'}", CaseSensitiveFieldBean1.class);
    assertEquals("foo", deserialized.VALUE);
  }

  @Test
  public void roundTripCaseSensitiveFieldBean2() {
    CaseSensitiveFieldBean2 bean = new CaseSensitiveFieldBean2();
    bean.value = "foo";
    assertJson("{'value': 'foo'}", serialize(bean));
    CaseSensitiveFieldBean2 deserialized =
        deserialize("{'value': 'foo'}", CaseSensitiveFieldBean2.class);
    assertEquals("foo", deserialized.value);
  }

  @Test
  public void roundTripCaseSensitiveFieldBean3() {
    CaseSensitiveFieldBean3 bean = new CaseSensitiveFieldBean3();
    bean.Value = "foo";
    assertJson("{'Value': 'foo'}", serialize(bean));
    CaseSensitiveFieldBean3 deserialized =
        deserialize("{'Value': 'foo'}", CaseSensitiveFieldBean3.class);
    assertEquals("foo", deserialized.Value);
  }

  @Test
  public void roundTripCaseSensitiveFieldBean4() {
    CaseSensitiveFieldBean4 bean = new CaseSensitiveFieldBean4();
    bean.valUE = "foo";
    assertJson("{'valUE': 'foo'}", serialize(bean));
    CaseSensitiveFieldBean4 deserialized =
        deserialize("{'valUE': 'foo'}", CaseSensitiveFieldBean4.class);
    assertEquals("foo", deserialized.valUE);
  }

  @Test
  public void roundTripUnicodeBean() {
    UnicodeBean bean = new UnicodeBean();
    bean.漢字 = "foo";
    assertJson("{'漢字': 'foo'}", serialize(bean));
    UnicodeBean deserialized = deserialize("{'漢字': 'foo'}", UnicodeBean.class);
    assertEquals("foo", deserialized.漢字);
  }

  @Test(expected = DatabaseException.class)
  public void shortsCantBeSerialized() {
    ShortBean bean = new ShortBean();
    bean.value = 1;
    serialize(bean);
  }

  @Test(expected = DatabaseException.class)
  public void bytesCantBeSerialized() {
    ByteBean bean = new ByteBean();
    bean.value = 1;
    serialize(bean);
  }

  @Test(expected = DatabaseException.class)
  public void charsCantBeSerialized() {
    CharBean bean = new CharBean();
    bean.value = 1;
    serialize(bean);
  }

  @Test(expected = DatabaseException.class)
  public void intArraysCantBeSerialized() {
    IntArrayBean bean = new IntArrayBean();
    bean.values = new int[] {1};
    serialize(bean);
  }

  @Test(expected = DatabaseException.class)
  public void objectArraysCantBeSerialized() {
    StringArrayBean bean = new StringArrayBean();
    bean.values = new String[] {"foo"};
    serialize(bean);
  }

  @Test(expected = DatabaseException.class)
  public void shortsCantBeDeserialized() {
    deserialize("{'value': 1}", ShortBean.class);
  }

  @Test(expected = DatabaseException.class)
  public void bytesCantBeDeserialized() {
    deserialize("{'value': 1}", ByteBean.class);
  }

  @Test(expected = DatabaseException.class)
  public void charsCantBeDeserialized() {
    deserialize("{'value': '1'}", CharBean.class);
  }

  @Test(expected = DatabaseException.class)
  public void intArraysCantBeDeserialized() {
    deserialize("{'values': [1]}", IntArrayBean.class);
  }

  @Test(expected = DatabaseException.class)
  public void objectArraysCantBeDeserialized() {
    deserialize("{'values': ['foo']}", StringArrayBean.class);
  }

  @Test
  public void publicConstructorCanBeDeserialized() {
    PublicConstructorBean bean = deserialize("{'value': 'foo'}", PublicConstructorBean.class);
    assertEquals("foo", bean.value);
  }

  @Test
  public void privateConstructorCanBeDeserialized() {
    PrivateConstructorBean bean = deserialize("{'value': 'foo'}", PrivateConstructorBean.class);
    assertEquals("foo", bean.value);
  }

  @Test(expected = DatabaseException.class)
  public void argConstructorCantBeDeserialized() {
    deserialize("{'value': 'foo'}", ArgConstructorBean.class);
  }

  @Test
  public void packageConstructorCanBeDeserialized() {
    PackageConstructorBean bean = deserialize("{'value': 'foo'}", PackageConstructorBean.class);
    assertEquals("foo", bean.value);
  }

  @Test
  public void multipleConstructorsCanBeDeserialized() {
    MultipleConstructorBean bean = deserialize("{'value': 'foo'}", MultipleConstructorBean.class);
    assertEquals("foo", bean.value);
  }

  @Test
  public void objectAcceptsAnyObject() {
    ObjectBean stringValue = deserialize("{'value': 'foo'}", ObjectBean.class);
    assertEquals("foo", stringValue.value);
    ObjectBean listValue = deserialize("{'value': ['foo']}", ObjectBean.class);
    assertEquals(Collections.singletonList("foo"), listValue.value);
    ObjectBean mapValue = deserialize("{'value': {'foo':'bar'}}", ObjectBean.class);
    assertEquals(fromSingleQuotedString("{'foo':'bar'}"), mapValue.value);
    String complex =
        "{'value': {'foo':['bar', ['baz'], {'bam': 'qux'}]}, " + "'other':{'a': ['b']}}";
    ObjectBean complexValue = deserialize(complex, ObjectBean.class);
    assertEquals(fromSingleQuotedString(complex).get("value"), complexValue.value);
  }

  @Test
  public void objectClassCanBePassedInAtTopLevel() {
    assertEquals("foo", CustomClassMapper.convertToCustomClass("foo", Object.class));
    assertEquals(1, CustomClassMapper.convertToCustomClass(1, Object.class));
    assertEquals(1L, CustomClassMapper.convertToCustomClass(1L, Object.class));
    assertEquals(true, CustomClassMapper.convertToCustomClass(true, Object.class));
    assertEquals(1.1, CustomClassMapper.convertToCustomClass(1.1, Object.class));
    List<String> fooList = Collections.singletonList("foo");
    assertEquals(fooList, CustomClassMapper.convertToCustomClass(fooList, Object.class));
    Map<String, String> fooMap = Collections.singletonMap("foo", "bar");
    assertEquals(fooMap, CustomClassMapper.convertToCustomClass(fooMap, Object.class));
  }

  @Test
  public void primitiveClassesCanBePassedInTopLevel() {
    assertEquals("foo", CustomClassMapper.convertToCustomClass("foo", String.class));
    assertEquals((Integer) 1, CustomClassMapper.convertToCustomClass(1, Integer.class));
    assertEquals((Long) 1L, CustomClassMapper.convertToCustomClass(1L, Long.class));
    assertEquals(true, CustomClassMapper.convertToCustomClass(true, Boolean.class));
    assertEquals((Double) 1.1, CustomClassMapper.convertToCustomClass(1.1, Double.class));
  }

  @Test(expected = DatabaseException.class)
  public void passingInListTopLevelThrows() {
    CustomClassMapper.convertToCustomClass(Collections.singletonList("foo"), List.class);
  }

  @Test(expected = DatabaseException.class)
  public void passingInMapTopLevelThrows() {
    CustomClassMapper.convertToCustomClass(Collections.singletonMap("foo", "bar"), Map.class);
  }

  @Test(expected = DatabaseException.class)
  public void passingInCharacterTopLevelThrows() {
    CustomClassMapper.convertToCustomClass('1', Character.class);
  }

  @Test(expected = DatabaseException.class)
  public void passingInShortTopLevelThrows() {
    CustomClassMapper.convertToCustomClass(1, Short.class);
  }

  @Test(expected = DatabaseException.class)
  public void passingInByteTopLevelThrows() {
    CustomClassMapper.convertToCustomClass(1, Byte.class);
  }

  @Test(expected = DatabaseException.class)
  public void passingInGenericBeanTopLevelThrows() {
    deserialize("{'value': 'foo'}", GenericBean.class);
  }

  @Test
  public void collectionsCanBeSerializedWhenList() {
    CollectionBean bean = new CollectionBean();
    bean.values = Collections.singletonList("foo");
    assertJson("{'values': ['foo']}", serialize(bean));
  }

  @Test(expected = DatabaseException.class)
  public void collectionsCantBeSerializedWhenSet() {
    CollectionBean bean = new CollectionBean();
    bean.values = Collections.singleton("foo");
    serialize(bean);
  }

  @Test(expected = DatabaseException.class)
  public void collectionsCantBeDeserialized() {
    deserialize("{'values': ['foo']}", CollectionBean.class);
  }

  @Test
  public void allowNullEverywhere() {
    assertNull(CustomClassMapper.convertToCustomClass(null, Integer.class));
    assertNull(CustomClassMapper.convertToCustomClass(null, String.class));
    assertNull(CustomClassMapper.convertToCustomClass(null, Double.class));
    assertNull(CustomClassMapper.convertToCustomClass(null, Long.class));
    assertNull(CustomClassMapper.convertToCustomClass(null, Boolean.class));
    assertNull(CustomClassMapper.convertToCustomClass(null, StringBean.class));
    assertNull(CustomClassMapper.convertToCustomClass(null, Object.class));
    assertNull(CustomClassMapper.convertToCustomClass(null, new GenericTypeIndicator<String>() {}));
    assertNull(
        CustomClassMapper.convertToCustomClass(
            null, new GenericTypeIndicator<Map<String, String>>() {}));
  }

  @Test
  public void parsingGenericBeansSupportedUsingGenericTypeIndicator() {
    GenericBean<String> stringBean =
        deserialize("{'value': 'foo'}", new GenericTypeIndicator<GenericBean<String>>() {});
    assertEquals("foo", stringBean.value);

    GenericBean<Map<String, String>> mapBean =
        deserialize(
            "{'value': {'foo': 'bar'}}",
            new GenericTypeIndicator<GenericBean<Map<String, String>>>() {});
    assertEquals(Collections.singletonMap("foo", "bar"), mapBean.value);

    GenericBean<List<String>> listBean =
        deserialize("{'value': ['foo']}", new GenericTypeIndicator<GenericBean<List<String>>>() {});
    assertEquals(Collections.singletonList("foo"), listBean.value);

    GenericBean<GenericBean<String>> recursiveBean =
        deserialize(
            "{'value': {'value': 'foo'}}",
            new GenericTypeIndicator<GenericBean<GenericBean<String>>>() {});
    assertEquals("foo", recursiveBean.value.value);

    DoubleGenericBean<String, Integer> doubleBean =
        deserialize(
            "{'valueA': 'foo', 'valueB': 1}",
            new GenericTypeIndicator<DoubleGenericBean<String, Integer>>() {});
    assertEquals("foo", doubleBean.valueA);
    assertEquals((Integer) 1, doubleBean.valueB);
  }

  @Test
  public void serializingGenericBeansSupported() {
    GenericBean<String> stringBean = new GenericBean<>();
    stringBean.value = "foo";
    assertJson("{'value': 'foo'}", serialize(stringBean));

    GenericBean<Map<String, String>> mapBean = new GenericBean<>();
    mapBean.value = Collections.singletonMap("foo", "bar");
    assertJson("{'value': {'foo': 'bar'}}", serialize(mapBean));

    GenericBean<List<String>> listBean = new GenericBean<>();
    listBean.value = Collections.singletonList("foo");
    assertJson("{'value': ['foo']}", serialize(listBean));

    GenericBean<GenericBean<String>> recursiveBean = new GenericBean<>();
    recursiveBean.value = new GenericBean<>();
    recursiveBean.value.value = "foo";
    assertJson("{'value': {'value': 'foo'}}", serialize(recursiveBean));

    DoubleGenericBean<String, Integer> doubleBean = new DoubleGenericBean<>();
    doubleBean.valueA = "foo";
    doubleBean.valueB = 1;
    assertJson("{'valueA': 'foo', 'valueB': 1}", serialize(doubleBean));
  }

  @Test(expected = DatabaseException.class)
  public void deserializingWrongTypeThrows() {
    deserialize("{'value': 'foo'}", WrongTypeBean.class);
  }

  @Test
  public void serializingWrongTypeWorks() {
    WrongTypeBean bean = new WrongTypeBean();
    bean.value = 1;
    assertJson("{'value': '1'}", serialize(bean));
  }

  @Test(expected = DatabaseException.class)
  public void extendingGenericTypeIndicatorIsForbidden1() {
    deserialize("{'value': 'foo'}", new GenericTypeIndicatorSubclass<GenericBean<String>>() {});
  }

  @Test(expected = DatabaseException.class)
  public void extendingGenericTypeIndicatorIsForbidden2() {
    deserialize("{'value': 'foo'}", new NonGenericTypeIndicatorSubclass() {});
  }

  @Test(expected = DatabaseException.class)
  public void extendingGenericTypeIndicatorIsForbidden3() {
    deserialize("{'value': 'foo'}", new NonGenericTypeIndicatorSubclassConcreteSubclass());
  }

  @Test
  public void subclassingGenericTypeIndicatorIsAllowed() {
    GenericBean<String> bean =
        deserialize("{'value': 'foo'}", new NonGenericTypeIndicatorConcreteSubclass());
    assertEquals("foo", bean.value);
  }

  @Test(expected = DatabaseException.class)
  public void unknownTypeParametersNotSupported() {
    deserialize("{'value': 'foo'}", new GenericTypeIndicatorSubclass<GenericBean<?>>() {});
  }

  @Test(expected = DatabaseException.class)
  public void unknownTypeParametersSupportedIfBoundedByKnownType() {
    GenericBean<? extends String> bean =
        deserialize(
            "{'value': 'foo'}",
            new GenericTypeIndicatorSubclass<GenericBean<? extends String>>() {});
    assertEquals("foo", bean.value);
  }

  @Test
  public void excludedFieldsAreExcluded() {
    ExcludedBean bean = new ExcludedBean();
    assertJson("{'includedGetter': 'no-value'}", serialize(bean));
  }

  @Test
  public void excludedFieldsAreNotParsed() {
    ExcludedBean bean =
        deserialize(
            "{'includedGetter': 'foo', 'excludedField': 'bar', " + "'excludedGetter': 'qux'}",
            ExcludedBean.class);
    assertEquals("no-value", bean.excludedField);
    assertEquals("no-value", bean.excludedGetter);
    assertEquals("foo", bean.includedGetter);
  }

  @Test
  public void excludedSettersAreIgnored() {
    ExcludedSetterBean bean = deserialize("{'value': 'foo'}", ExcludedSetterBean.class);