Start testing total conversions between Scala and Java collections

chimney-java-collections/src/main/scala/io/scalaland/chimney/javacollections/JavaCollectionsTotalTransformerImplicits.scala

@@ -5,7 +5,7 @@ import io.scalaland.chimney.Transformer
 import scala.collection.compat.*
 
 /** @since 0.8.1 */
-trait JavaCollectionsTotalTransformerImplicits {
+trait JavaCollectionsTotalTransformerImplicits extends JavaCollectionsTotalTransformerLowPriorityImplicits1 {
 
   // Optionals
 
@@ -151,3 +151,77 @@ trait JavaCollectionsTotalTransformerImplicits {
       builder.result()
     }
 }
+
+private[javacollections] trait JavaCollectionsTotalTransformerLowPriorityImplicits1 {
+
+  // Dictionaries
+
+  /** @since 0.8.1 */
+  implicit def totalTransformerFromJavaDictionaryToScalaMap[
+      JMap[K0, V0] <: java.util.Dictionary[K0, V0],
+      SMap[K0, V0] <: scala.collection.Map[K0, V0],
+      K1,
+      V1,
+      K2,
+      V2
+  ](implicit
+      keys: Transformer[K1, K2],
+      values: Transformer[V1, V2],
+      factory: Factory[(K2, V2), SMap[K2, V2]]
+  ): Transformer[JMap[K1, V1], SMap[K2, V2]] =
+    collection => {
+      val builder = factory.newBuilder
+      val it = collection.keys()
+      while (it.hasMoreElements()) {
+        val key = it.nextElement()
+        builder += (keys.transform(key) -> values.transform(collection.get(key)))
+      }
+      builder.result()
+    }
+
+  /** @since 0.8.1 */
+  implicit def totalTransformerFromScalaMapToJavaDictionary[
+      SMap[K0, V0] <: scala.collection.Map[K0, V0],
+      JMap[K0, V0] <: java.util.Dictionary[K0, V0],
+      K1,
+      V1,
+      K2,
+      V2
+  ](implicit
+      keys: Transformer[K1, K2],
+      values: Transformer[V1, V2],
+      factory: JavaFactory[(K2, V2), JMap[K2, V2]]
+  ): Transformer[SMap[K1, V1], JMap[K2, V2]] =
+    collection => {
+      val builder = factory.newBuilder
+      val it = collection.iterator
+      while (it.hasNext) {
+        val pair = it.next()
+        builder.addOne(keys.transform(pair._1) -> values.transform(pair._2))
+      }
+      builder.result()
+    }
+
+  /** @since 0.8.1 */
+  implicit def totalTransformerFromJavaMapToJavaDictionary[
+      JMap1[K0, V0] <: java.util.Dictionary[K0, V0],
+      JMap2[K0, V0] <: java.util.Dictionary[K0, V0],
+      K1,
+      V1,
+      K2,
+      V2
+  ](implicit
+      keys: Transformer[K1, K2],
+      values: Transformer[V1, V2],
+      factory: JavaFactory[(K2, V2), JMap2[K2, V2]]
+  ): Transformer[JMap1[K1, V1], JMap2[K2, V2]] =
+    collection => {
+      val builder = factory.newBuilder
+      val it = collection.keys()
+      while (it.hasMoreElements()) {
+        val key = it.nextElement()
+        builder.addOne(keys.transform(key) -> values.transform(collection.get(key)))
+      }
+      builder.result()
+    }
+}

chimney-java-collections/src/test/scala/io/scalaland/chimney/javacollections/JavaFactorySpec.scala

@@ -125,7 +125,7 @@ class JavaFactorySpec extends ChimneySpec {
     convertAndVerifySorted[String, Int, ju.TreeMap]("d" -> 10, "c" -> 8, "b" -> 4, "a" -> 0)
   }
 
-  test("java.util.Collection instances should be resolved for java.util.Enum specializations") {
+  test("java.util.Collection instances should be resolved for java.lang.Enum specializations") {
     val enumSet = implicitly[JavaFactory[JavaEnum, ju.EnumSet[JavaEnum]]]
       .fromSpecific(Iterator(JavaEnum.Blue, JavaEnum.Green, JavaEnum.Red))
     val enumMap = implicitly[JavaFactory[(JavaEnum, Int), ju.EnumMap[JavaEnum, Int]]].fromSpecific(

chimney-java-collections/src/test/scala/io/scalaland/chimney/javacollections/TotalTransformerJavaCollectionsConversionsSpec.scala

@@ -0,0 +1,104 @@
+package io.scalaland.chimney.javacollections
+
+import java.util as ju
+import io.scalaland.chimney.{ChimneySpec, Transformer}
+import io.scalaland.chimney.dsl.*
+
+import scala.collection.immutable.ListMap
+import scala.jdk.CollectionConverters.*
+
+class TotalTransformerJavaCollectionsConversionsSpec extends ChimneySpec {
+
+  // TODO: options
+
+  // TODO iterator and enumeration
+  // Seq(4,3,2,1).transformInto[ju.Iterator[String]].asScala.toList ==> List("4","3","2","1")
+  // Seq(4,3,2,1).transformInto[ju.Enumeration[String]].asScala.toList ==> List("4","3","2","1")
+
+  group("conversion from Scala types to java.util.Collection types") {
+
+    test("to non-Map types") {
+      implicit val intToString: Transformer[Int, String] = _.toString
+
+      val input = Seq(4, 3, 2, 1)
+      val outputStable = List("4", "3", "2", "1")
+      val outputUnstable = Set("4", "3", "2", "1")
+      val outputSorted = List("1", "2", "3", "4")
+
+      input.transformInto[ju.Collection[String]].asScala.toSet ==> outputUnstable
+      input.transformInto[ju.AbstractCollection[String]].asScala.toSet ==> outputUnstable
+
+      input.transformInto[ju.List[String]].asScala.toList ==> outputStable
+      input.transformInto[ju.AbstractList[String]].asScala.toList ==> outputStable
+      input.transformInto[ju.AbstractSequentialList[String]].asScala.toList ==> outputStable
+      input.transformInto[ju.ArrayList[String]].asScala.toList ==> outputStable
+      input.transformInto[ju.LinkedList[String]].asScala.toList ==> outputStable
+      input.transformInto[ju.Vector[String]].asScala.toList ==> outputStable
+      input.transformInto[ju.Stack[String]].asScala.toList ==> outputStable
+
+      input.transformInto[ju.Deque[String]].asScala.toList ==> outputStable
+      input.transformInto[ju.ArrayDeque[String]].asScala.toList ==> outputStable
+
+      input.transformInto[ju.Queue[String]].asScala.toList ==> outputSorted
+      input.transformInto[ju.AbstractQueue[String]].asScala.toList ==> outputSorted
+      input.transformInto[ju.PriorityQueue[String]].asScala.toList ==> outputSorted
+
+      input.transformInto[ju.Set[String]].asScala.toSet ==> outputUnstable
+      input.transformInto[ju.AbstractSet[String]].asScala.toSet ==> outputUnstable
+      input.transformInto[ju.SortedSet[String]].asScala.toList ==> outputSorted
+      input.transformInto[ju.NavigableSet[String]].asScala.toList ==> outputSorted
+      input.transformInto[ju.HashSet[String]].asScala.toSet ==> outputUnstable
+      input.transformInto[ju.LinkedHashSet[String]].asScala.toList ==> outputStable
+      input.transformInto[ju.TreeSet[String]].asScala.toList ==> outputSorted
+    }
+
+    test("to java.util.Dictionary types") {
+      implicit val intToString: Transformer[Int, String] = _.toString
+
+      val input = ListMap(4 -> 4, 3 -> 3, 2 -> 2, 1 -> 1)
+      val output = Map("4" -> "4", "3" -> "3", "2" -> "2", "1" -> "1")
+
+      input.transformInto[ju.Dictionary[String, String]].asScala ==> output
+      (input.transformInto[ju.Hashtable[String, String]]: ju.Dictionary[String, String]).asScala ==> output
+    }
+
+    test("to java.util.Map types") {
+      implicit val intToString: Transformer[Int, String] = _.toString
+
+      val input = ListMap(4 -> 4, 3 -> 3, 2 -> 2, 1 -> 1)
+      val outputStable = List("4" -> "4", "3" -> "3", "2" -> "2", "1" -> "1")
+      val outputUnstable = Map("4" -> "4", "3" -> "3", "2" -> "2", "1" -> "1")
+      val outputSorted = List("1" -> "1", "2" -> "2", "3" -> "3", "4" -> "4")
+
+      input.transformInto[ju.Map[String, String]].asScala ==> outputUnstable
+      input.transformInto[ju.AbstractMap[String, String]].asScala ==> outputUnstable
+      input.transformInto[ju.SortedMap[String, String]].asScala.toList ==> outputSorted
+      input.transformInto[ju.NavigableMap[String, String]].asScala.toList ==> outputSorted
+      input.transformInto[ju.HashMap[String, String]].asScala ==> outputUnstable
+      input.transformInto[ju.LinkedHashMap[String, String]].asScala.toList ==> outputStable
+      input.transformInto[ju.TreeMap[String, String]].asScala.toList ==> outputSorted
+    }
+
+    test("to java.lang.Enum-supporting types".ignore) {} // TODO
+  }
+
+  group("conversion from java.util.Collection types to Scala types") {
+
+    test("from non-Map types".ignore) {} // TODO
+    test("from java.util.Dictionary types".ignore) {} // TODO
+    test("from java.util.Map types".ignore) {} // TODO
+  }
+
+  group("conversion from java.util.Collection types to java.util.Collection types") {
+
+    test("for non-Map types".ignore) {} // TODO
+    test("for java.util.Dictionary types".ignore) {} // TODO
+    test("for java.util.Map types".ignore) {} // TODO
+  }
+
+  group("java.util.BitSet conversions") {
+
+    test("from Scala types".ignore) {} // TODO
+    test("to Scala types".ignore) {} // TODO
+  }
+}