Define equality between converter wrappers

[RustedBones]

When converter destination collection does not have equality defined, we should override equals/hashcode. 2 wrappers with same underlying collection should be equal.

Follow-up for scala/bug#12683

[som-snytt]

Thanks! It took me a while to realize this is a PR not a new ticket. I was looking at previous EqualsTest, but maybe it doesn't matter where the tests reside.

[som-snytt]

I confirmed (if it needed confirming) that the scio test passes with this change.

The following is a note to myself, so I don't have to tattoo it on my arm.

I'm not persuaded by delegating for the iterator wrappers, but it's also harmless, perhaps. (And it has the air of completeness.)

So the material change is for JIterableWrapper and JCollectionWrapper. I don't remember if there was a reason they were excluded from the previous fix; maybe it was just an oversight, or the result of zealous minimalism.

Refreshing my memory, I'm a bit surprised by:

scala> val xs = List(1,2,3).asJava
val xs: java.util.List[Int] = [1, 2, 3]

scala> .getClass
val res0: Class[_ <: java.util.List[Int]] = class scala.collection.convert.JavaCollectionWrappers$SeqWrapper

def set(x$1: Int, x$2: Int): Int

scala> xs.set(0, 42)
java.lang.UnsupportedOperationException
  at java.base/java.util.AbstractList.set(AbstractList.java:138)
  ... 30 elided

scala> xs.asScala
val res2: scala.collection.mutable.Buffer[Int] = Buffer(1, 2, 3)

scala> .getClass
val res3: Class[_ <: scala.collection.mutable.Buffer[Int]] = class scala.collection.convert.JavaCollectionWrappers$JListWrapper

scala> res2(0) = 42
java.lang.UnsupportedOperationException
  at java.base/java.util.AbstractList.set(AbstractList.java:138)
  at scala.collection.convert.JavaCollectionWrappers$JListWrapper.update(JavaCollectionWrappers.scala:126)
  ... 30 elided

That seems to me unhelpful. However, in the context of this PR, it endorses just delegating, come what may. The wrappers are the thinnest of veneers. (I almost wrote Venners.)

My other thought is that arbitrary wrappers with the same (eq) underlying should compare equal.

scala> val ns = List(1,2,3)
val ns: List[Int] = List(1, 2, 3)

scala> val xs = ns.asJava
val xs: java.util.List[Int] = [1, 2, 3]

scala> val ys = ns.asInstanceOf[Iterable[Int]].asJava
val ys: Iterable[Int] = [1, 2, 3]

scala> xs == ys
val res3: Boolean = false

A hypothetical rogue wrapper, RandomizedSeqWrapper, would break equality on java.util.List which requires "same elements in same order".

[som-snytt]

Straightforward and complete. I had a couple of test tweaks but it can wait for another occasion.

[lrytz]

So IIUC, the strategy is to override equals unless the wrapper class already inherits equals (e.g., SeqWrapper, JSetWrapper), right?

If so, should we add equality to DictionaryWrapper?

scala> val m = collection.mutable.Map(1 -> 1)
val m: scala.collection.mutable.Map[Int,Int] = HashMap(1 -> 1)

scala> m.asJavaDictionary == m.asJavaDictionary
val res18: Boolean = false