Update BeanAdapter.

Author: gk-brown

build.gradle

@@ -14,7 +14,7 @@
 
 subprojects {
     group = 'org.httprpc'
-    version = '6.1'
+    version = '6.1.1'
 
     repositories {
         mavenCentral()

kilo-client/src/main/java/org/httprpc/kilo/beans/BeanAdapter.java

@@ -52,6 +52,10 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.TreeMap;
+import java.util.TreeSet;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
@@ -687,6 +691,11 @@ public static Object coerceGeneric(Object value, Type type) {
             case Class<?> rawType -> toRawType(value, rawType);
             case ParameterizedType parameterizedType -> {
                 var rawType = (Class<?>)parameterizedType.getRawType();
+
+                if (!rawType.isInterface()) {
+                    throw new IllegalArgumentException("Invalid parameterized type.");
+                }
+
                 var actualTypeArguments = parameterizedType.getActualTypeArguments();
 
                 if (rawType == List.class) {
@@ -705,14 +714,14 @@ public static Object coerceGeneric(Object value, Type type) {
                     } else {
                         throw new IllegalArgumentException("Value is not a collection.");
                     }
-                } else if (rawType == Map.class) {
+                } else if (Map.class.isAssignableFrom(rawType)) {
                     if (value == null) {
                         yield null;
                     } else if (value instanceof Map<?, ?> map) {
                         var keyType = actualTypeArguments[0];
                         var valueType = actualTypeArguments[1];
 
-                        var genericMap = new LinkedHashMap<>(map.size());
+                        var genericMap = (rawType == SortedMap.class) ? new TreeMap<>() : new LinkedHashMap<>(map.size());
 
                         for (var entry : map.entrySet()) {
                             genericMap.put(coerceGeneric(entry.getKey(), keyType), coerceGeneric(entry.getValue(), valueType));
@@ -722,13 +731,13 @@ public static Object coerceGeneric(Object value, Type type) {
                     } else {
                         throw new IllegalArgumentException("Value is not a map.");
                     }
-                } else if (rawType == Set.class) {
+                } else if (Set.class.isAssignableFrom(rawType)) {
                     if (value == null) {
                         yield null;
                     } else if (value instanceof Collection<?> collection) {
                         var elementType = actualTypeArguments[0];
 
-                        var genericSet = new LinkedHashSet<>(collection.size());
+                        var genericSet = (rawType == SortedSet.class) ? new TreeSet<>() : new LinkedHashSet<>(collection.size());
 
                         for (var element : collection) {
                             genericSet.add(coerceGeneric(element, elementType));

kilo-client/src/test/java/org/httprpc/kilo/beans/BeanAdapterTest.java

@@ -18,6 +18,7 @@
 import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import java.math.BigInteger;
 import java.net.URI;
 import java.nio.file.Path;
@@ -29,11 +30,16 @@
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.Period;
+import java.util.Arrays;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.SequencedMap;
+import java.util.SequencedSet;
 import java.util.Set;
+import java.util.SortedMap;
+import java.util.SortedSet;
 import java.util.UUID;
 
 import static org.httprpc.kilo.util.Collections.*;
@@ -265,19 +271,32 @@ public void testPathCoercion() {
     @Test
     public void testListCoercion() {
         assertInstanceOf(List.class, BeanAdapter.coerce(listOf(), List.class));
-        assertThrows(IllegalArgumentException.class, () -> BeanAdapter.coerce(123, List.class));
+
+        assertInstanceOf(List.class, BeanAdapter.coerceGeneric(listOf(), parameterizedTypeOf(List.class)));
+
+        assertThrows(IllegalArgumentException.class, () -> BeanAdapter.coerce(0, List.class));
     }
 
     @Test
     public void testMapCoercion() {
         assertInstanceOf(Map.class, BeanAdapter.coerce(mapOf(), Map.class));
-        assertThrows(IllegalArgumentException.class, () -> BeanAdapter.coerce(123, Map.class));
+
+        assertInstanceOf(Map.class, BeanAdapter.coerceGeneric(mapOf(), parameterizedTypeOf(Map.class)));
+        assertInstanceOf(SequencedMap.class, BeanAdapter.coerceGeneric(mapOf(), parameterizedTypeOf(SequencedMap.class)));
+        assertInstanceOf(SortedMap.class, BeanAdapter.coerceGeneric(mapOf(), parameterizedTypeOf(SortedMap.class)));
+
+        assertThrows(IllegalArgumentException.class, () -> BeanAdapter.coerce(0, Map.class));
     }
 
     @Test
     public void testSetCoercion() {
         assertInstanceOf(Set.class, BeanAdapter.coerce(setOf(), Set.class));
-        assertThrows(IllegalArgumentException.class, () -> BeanAdapter.coerce(123, Set.class));
+
+        assertInstanceOf(Set.class, BeanAdapter.coerceGeneric(setOf(), parameterizedTypeOf(Set.class)));
+        assertInstanceOf(SequencedSet.class, BeanAdapter.coerceGeneric(setOf(), parameterizedTypeOf(SequencedSet.class)));
+        assertInstanceOf(SortedSet.class, BeanAdapter.coerceGeneric(setOf(), parameterizedTypeOf(SortedSet.class)));
+
+        assertThrows(IllegalArgumentException.class, () -> BeanAdapter.coerce(0, Set.class));
     }
 
     @Test
@@ -486,4 +505,27 @@ public void testToType() {
 
         assertEquals(listOf(1, 2, 3), integers);
     }
+
+    private static Type parameterizedTypeOf(Class<?> rawType) {
+        return new ParameterizedType() {
+            @Override
+            public Type[] getActualTypeArguments() {
+                var actualTypeArguments = new Type[rawType.getTypeParameters().length];
+
+                Arrays.fill(actualTypeArguments, Object.class);
+
+                return actualTypeArguments;
+            }
+
+            @Override
+            public Type getRawType() {
+                return rawType;
+            }
+
+            @Override
+            public Type getOwnerType() {
+                return null;
+            }
+        };
+    }
 }