Improve testing of generics.

An additional fix from Firestore for handling TypeVariables.

Author: rlazo

firebase-database/src/main/java/com/google/firebase/database/core/utilities/encoding/CustomClassMapper.java

@@ -187,8 +187,14 @@ private static <T> T deserializeToType(Object o, Type type) {
       // that this array always has at least one element, since the unbounded wildcard <?> always
       // has at least an upper bound of Object.
       Type[] upperBounds = ((WildcardType) type).getUpperBounds();
-      hardAssert(upperBounds.length > 0, "Unexpected type bounds on wildcard " + type);
+      hardAssert(upperBounds.length > 0, "Wildcard type " + type + " is not upper bounded.");
       return deserializeToType(o, upperBounds[0]);
+    } else if (type instanceof TypeVariable) {
+      // As above, TypeVariables always have at least one upper bound of Object.
+      Type[] upperBounds = ((TypeVariable<?>) type).getBounds();
+      hardAssert(upperBounds.length > 0, "Wildcard type " + type + " is not upper bounded.");
+      return deserializeToType(o, upperBounds[0]);
+
     } else if (type instanceof GenericArrayType) {
       throw new DatabaseException(
           "Generic Arrays are not supported, please use Lists " + "instead");

firebase-database/src/test/java/com/google/firebase/database/MapperTest.java

@@ -21,6 +21,7 @@
 
 import androidx.annotation.Keep;
 import com.google.firebase.database.core.utilities.encoding.CustomClassMapper;
+import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -628,6 +629,22 @@ public String getValue() {
     }
   }
 
+  private static class MultiBoundedMapBean<T extends String & Serializable> {
+    private Map<String, T> values;
+
+    public Map<String, T> getValues() {
+      return values;
+    }
+  }
+
+  private static class MultiBoundedMapHolderBean {
+    private MultiBoundedMapBean<String> map;
+
+    public MultiBoundedMapBean<String> getMap() {
+      return map;
+    }
+  }
+
   private static class StaticFieldBean {
     public static String value1 = "static-value";
     public String value2;
@@ -1772,6 +1789,24 @@ public void usingWildcardInGenericTypeIndicatorIsAllowed() {
             fooMap, new GenericTypeIndicator<Map<String, ? extends String>>() {}));
   }
 
+  @Test(expected = DatabaseException.class)
+  public void usingLowerBoundWildcardsIsForbidden() {
+    Map<String, String> fooMap = Collections.singletonMap("foo", "bar");
+    CustomClassMapper.convertToCustomClass(
+        fooMap, new GenericTypeIndicator<Map<String, ? super String>>() {});
+  }
+
+  @Test
+  public void multiBoundedWildcardsUsesTheFirst() {
+    Map<String, Object> source =
+        Collections.singletonMap(
+            "map", Collections.singletonMap("values", Collections.singletonMap("foo", "bar")));
+    MultiBoundedMapHolderBean bean =
+        CustomClassMapper.convertToCustomClass(source, MultiBoundedMapHolderBean.class);
+    Map<String, String> expected = Collections.singletonMap("foo", "bar");
+    assertEquals(expected, bean.map.values);
+  }
+
   @Test(expected = DatabaseException.class)
   public void unknownTypeParametersNotSupported() {
     deserialize("{'value': 'foo'}", new GenericTypeIndicatorSubclass<GenericBean<?>>() {});