Merge pull request scala#8417 from som-snytt/tweak/reachability

Improve reachability test

Author: retronym

src/testkit/scala/tools/testkit/AssertUtil.scala

@@ -107,25 +107,24 @@ object AssertUtil {
    */
   def assertNotReachable[A <: AnyRef](a: => A, roots: AnyRef*)(body: => Unit): Unit = {
     val wkref = new WeakReference(a)
-    def refs(root: AnyRef): mutable.Set[AnyRef] = {
+    // fail if following strong references from root discovers referent. Quit if ref is empty.
+    def assertNoRef(root: AnyRef): Unit = {
       val seen = new IdentityHashMap[AnyRef, Unit]
       def loop(o: AnyRef): Unit =
         if (wkref.nonEmpty && o != null && !seen.containsKey(o)) {
           seen.put(o, ())
+          assertTrue(s"Root $root held reference $o", o ne wkref.get)
           for {
             f <- o.getClass.allFields
             if !Modifier.isStatic(f.getModifiers)
             if !f.getType.isPrimitive
             if !classOf[Reference[_]].isAssignableFrom(f.getType)
-          } loop(f follow o)
+          } loop(f.follow(o))
         }
       loop(root)
-      seen.keySet.asScala
     }
     body
-    for (r <- roots if wkref.nonEmpty) {
-      assertFalse(s"Root $r held reference", refs(r) contains wkref.get)
-    }
+    roots.foreach(assertNoRef)
   }
 
   /** Assert no new threads, with some margin for arbitrary threads to exit. */

test/junit/scala/collection/IteratorTest.scala

@@ -631,6 +631,7 @@ class IteratorTest {
 
   @Test def `flatMap is memory efficient in previous element`(): Unit = {
     import java.lang.ref._
+    import scala.util.chaining._
     // Array.iterator holds onto array reference; by contrast, iterating over List walks tail.
     // Avoid reaching seq1 through test class. Avoid testing Array.iterator.
     class C extends Iterable[String] {
@@ -641,11 +642,7 @@ class IteratorTest {
 
         def hasNext = i < ss.length
 
-        def next() =
-          if (hasNext) {
-            val res = ss(i); i += 1; res
-          }
-          else Iterator.empty.next()
+        def next() = if (hasNext) ss(i).tap(_ => i += 1) else Iterator.empty.next()
       }
 
       def apply(i: Int) = ss(i)
@@ -654,13 +651,14 @@ class IteratorTest {
     val seq2 = List("third")
     val it0: Iterator[Int] = Iterator(1, 2)
     lazy val it: Iterator[String] = it0.flatMap {
-      case 1 => seq1.get
-      case _ => check(); seq2
+      case 1 => Option(seq1.get).getOrElse(Nil)
+      case 2 => check(); seq2
+      case _ => ???
     }
 
     def check() = assertNotReachable(seq1.get, it)(())
 
-    def checkHasElement() = assertNotReachable(seq1.get.apply(1), it)(())
+    def checkHasElement() = assertNotReachable(Option(seq1.get).map(_.apply(1)).orNull, it)(())
 
     assert(it.hasNext)
     assertEquals("first", it.next())