Tweaks and classBytes

Author: som-snytt

compiler/test/dotty/tools/repl/AbstractFileClassLoaderTest.scala

@@ -1,27 +1,41 @@
 package dotty.tools.repl
 
-import org.junit.Assert._
+import org.junit.Assert.*
 import org.junit.Test
 
 class AbstractFileClassLoaderTest:
 
   import dotty.tools.io.{AbstractFile, VirtualDirectory}
-  import scala.io.Source
-  import scala.io.Codec, Codec.UTF8
-  import java.io.{Closeable, InputStream}
+  import scala.collection.mutable.ArrayBuffer
+  import scala.io.{Codec, Source}, Codec.UTF8
+  import java.io.{BufferedInputStream, Closeable, InputStream}
   import java.net.{URLClassLoader, URL}
 
-  implicit def `we love utf8`: Codec = UTF8
+  given `we love utf8`: Codec = UTF8
 
-  /** Call a function on something Closeable, finally closing it. */
   def closing[T <: Closeable, U](stream: T)(f: T => U): U = try f(stream) finally stream.close()
 
   extension (f: AbstractFile) def writeContent(s: String): Unit = closing(f.bufferedOutput)(_.write(s.getBytes(UTF8.charSet)))
-  def slurp(inputStream: => InputStream)(implicit codec: Codec): String =
-    val src = Source.fromInputStream(inputStream)(codec)
-    try src.mkString finally src.close()  // Always Be Closing
+  def slurp(inputStream: => InputStream)(implicit codec: Codec): String = closing(Source.fromInputStream(inputStream)(codec))(_.mkString)
   def slurp(url: URL)(implicit codec: Codec): String = slurp(url.openStream())
 
+  extension (input: InputStream) def bytes: Array[Byte] =
+    val bis = new BufferedInputStream(input)
+    val it  = Iterator.continually(bis.read()).takeWhile(_ != -1).map(_.toByte)
+    new ArrayBuffer[Byte]().addAll(it).toArray
+
+  // cf ScalaClassLoader#classBytes
+  extension (loader: ClassLoader)
+    // An InputStream representing the given class name, or null if not found.
+    def classAsStream(className: String) = loader.getResourceAsStream {
+      if className.endsWith(".class") then className
+      else s"${className.replace('.', '/')}.class"  // classNameToPath
+    }
+    // The actual bytes for a class file, or an empty array if it can't be found.
+    def classBytes(className: String): Array[Byte] = classAsStream(className) match
+      case null   => Array()
+      case stream => stream.bytes
+
   val NoClassLoader: ClassLoader = null
 
   // virtual dir "fuzz" and "fuzz/buzz/booz.class"
@@ -31,24 +45,21 @@ class AbstractFileClassLoaderTest:
     val booz = buzz.fileNamed("booz.class")
     (fuzz, booz)
 
-  @Test
-  def afclGetsParent(): Unit =
+  @Test def afclGetsParent(): Unit =
     val p = new URLClassLoader(Array.empty[URL])
     val d = new VirtualDirectory("vd", None)
     val x = new AbstractFileClassLoader(d, p)
     assertSame(p, x.getParent)
 
-  @Test
-  def afclGetsResource(): Unit =
+  @Test def afclGetsResource(): Unit =
     val (fuzz, booz) = fuzzBuzzBooz
     booz.writeContent("hello, world")
     val sut = new AbstractFileClassLoader(fuzz, NoClassLoader)
     val res = sut.getResource("buzz/booz.class")
     assertNotNull("Find buzz/booz.class", res)
     assertEquals("hello, world", slurp(res))
 
-  @Test
-  def afclGetsResourceFromParent(): Unit =
+  @Test def afclGetsResourceFromParent(): Unit =
     val (fuzz, booz) = fuzzBuzzBooz
     val (fuzz_, booz_) = fuzzBuzzBooz
     booz.writeContent("hello, world")
@@ -59,8 +70,7 @@ class AbstractFileClassLoaderTest:
     assertNotNull("Find buzz/booz.class", res)
     assertEquals("hello, world", slurp(res))
 
-  @Test
-  def afclGetsResourceInDefaultPackage(): Unit =
+  @Test def afclGetsResourceInDefaultPackage(): Unit =
     val fuzz = new VirtualDirectory("fuzz", None)
     val booz = fuzz.fileNamed("booz.class")
     val bass = fuzz.fileNamed("bass")
@@ -73,8 +83,7 @@ class AbstractFileClassLoaderTest:
     assertEquals("lo tone", slurp(sut.getResource("bass")))
 
   // scala/bug#8843
-  @Test
-  def afclGetsResources(): Unit =
+  @Test def afclGetsResources(): Unit =
     val (fuzz, booz) = fuzzBuzzBooz
     booz.writeContent("hello, world")
     val sut = new AbstractFileClassLoader(fuzz, NoClassLoader)
@@ -83,8 +92,7 @@ class AbstractFileClassLoaderTest:
     assertEquals("hello, world", slurp(e.nextElement))
     assertFalse(e.hasMoreElements)
 
-  @Test
-  def afclGetsResourcesFromParent(): Unit =
+  @Test def afclGetsResourcesFromParent(): Unit =
     val (fuzz, booz) = fuzzBuzzBooz
     val (fuzz_, booz_) = fuzzBuzzBooz
     booz.writeContent("hello, world")
@@ -98,36 +106,29 @@ class AbstractFileClassLoaderTest:
     assertEquals("hello, world_", slurp(e.nextElement))
     assertFalse(e.hasMoreElements)
 
-  @Test
-  def afclGetsResourceAsStream(): Unit =
+  @Test def afclGetsResourceAsStream(): Unit =
     val (fuzz, booz) = fuzzBuzzBooz
     booz.writeContent("hello, world")
     val x = new AbstractFileClassLoader(fuzz, NoClassLoader)
     val r = x.getResourceAsStream("buzz/booz.class")
     assertNotNull(r)
     assertEquals("hello, world", closing(r)(is => Source.fromInputStream(is).mkString))
 
-  /*
-  @Test
-  def afclGetsClassBytes(): Unit = {
+  @Test def afclGetsClassBytes(): Unit =
     val (fuzz, booz) = fuzzBuzzBooz
-    booz writeContent "hello, world"
-    val x = new AbstractFileClassLoader(fuzz, NoClassLoader)
-    val b = x.classBytes("buzz/booz.class")
+    booz.writeContent("hello, world")
+    val sut = new AbstractFileClassLoader(fuzz, NoClassLoader)
+    val b = sut.classBytes("buzz/booz.class")
     assertEquals("hello, world", new String(b, UTF8.charSet))
-  }
 
-  @Test
-  def afclGetsClassBytesFromParent(): Unit = {
+  @Test def afclGetsClassBytesFromParent(): Unit =
     val (fuzz, booz) = fuzzBuzzBooz
     val (fuzz_, booz_) = fuzzBuzzBooz
-    booz writeContent "hello, world"
-    booz_ writeContent "hello, world_"
+    booz.writeContent("hello, world")
+    booz_.writeContent("hello, world_")
 
     val p = new AbstractFileClassLoader(fuzz, NoClassLoader)
-    val x = new AbstractFileClassLoader(fuzz_, p)
-    val b = x.classBytes("buzz/booz.class")
+    val sut = new AbstractFileClassLoader(fuzz_, p)
+    val b = sut.classBytes("buzz/booz.class")
     assertEquals("hello, world", new String(b, UTF8.charSet))
-  }
-  */
 end AbstractFileClassLoaderTest