Support fs2.io.toInputStream[Resource] on Scala Native and run tests

Author: lolgab

build.sbt

@@ -378,7 +378,8 @@ lazy val root = tlCrossRootProject
 
 lazy val commonNativeSettings = Seq[Setting[?]](
   tlVersionIntroduced := List("2.12", "2.13", "3").map(_ -> "3.13.0").toMap,
-  Test / nativeBrewFormulas += "openssl"
+  Test / nativeBrewFormulas += "openssl",
+  Test / nativeConfig ~= { _.withEmbedResources(true) }
 )
 
 lazy val core = crossProject(JVMPlatform, JSPlatform, NativePlatform)

…scala/fs2/io/JavaInputOutputStream.scala …scala/fs2/io/JavaInputOutputStream.scalaio/jvm/src/main/scala/fs2/io/JavaInputOutputStream.scala renamed to io/jvm-native/src/main/scala/fs2/io/JavaInputOutputStream.scala io/jvm/src/main/scala/fs2/io/JavaInputOutputStream.scala renamed to io/jvm-native/src/main/scala/fs2/io/JavaInputOutputStream.scala

@@ -110,4 +110,26 @@ private[fs2] trait iojvmnative {
     }
   }
 
+  /** Pipe that converts a stream of bytes to a stream that will emit a single `java.io.InputStream`,
+    * that is closed whenever the resulting stream terminates.
+    *
+    * If the `close` of resulting input stream is invoked manually, then this will await until the
+    * original stream completely terminates.
+    *
+    * Because all `InputStream` methods block (including `close`), the resulting `InputStream`
+    * should be consumed on a different thread pool than the one that is backing the effect.
+    *
+    * Note that the implementation is not thread safe -- only one thread is allowed at any time
+    * to operate on the resulting `java.io.InputStream`.
+    */
+  def toInputStream[F[_]: Async]: Pipe[F, Byte, InputStream] =
+    source => Stream.resource(toInputStreamResource(source))
+
+  /** Like [[toInputStream]] but returns a `Resource` rather than a single element stream.
+    */
+  def toInputStreamResource[F[_]: Async](
+      source: Stream[F, Byte]
+  ): Resource[F, InputStream] =
+    JavaInputOutputStream.toInputStream(source)
+
 }

io/jvm-native/src/main/scala/fs2/io/iojvmnative.scala

@@ -275,7 +275,8 @@ class IoPlatformSuite extends Fs2Suite {
       bar.assertEquals("bar")
     }
     test("classloader") {
-      val size = readClassLoaderResource[IO]("fs2/io/foo", 8192).as(1L).compile.foldMonoid
+      val resourcePath = if (isNative) "/fs2/io/foo" else "fs2/io/foo"
+      val size = readClassLoaderResource[IO](resourcePath, 8192).as(1L).compile.foldMonoid
       size.assertEquals(3L)
     }
   }

…/test/scala/fs2/io/IoPlatformSuite.scala …/test/scala/fs2/io/IoPlatformSuite.scalaio/jvm/src/test/scala/fs2/io/IoPlatformSuite.scala renamed to io/jvm-native/src/test/scala/fs2/io/IoPlatformSuite.scala io/jvm/src/test/scala/fs2/io/IoPlatformSuite.scala renamed to io/jvm-native/src/test/scala/fs2/io/IoPlatformSuite.scala

@@ -23,12 +23,11 @@ package fs2
 package io
 
 import cats.Show
-import cats.effect.kernel.{Async, Resource, Sync}
+import cats.effect.kernel.{Async, Sync}
 import cats.effect.kernel.implicits._
 import cats.syntax.all._
 import fs2.internal.ThreadFactories
 
-import java.io.InputStream
 import java.nio.charset.Charset
 import java.nio.charset.StandardCharsets
 import java.util.concurrent.Executors
@@ -92,28 +91,6 @@ private[fs2] trait ioplatform extends iojvmnative {
   ): Pipe[F, O, Nothing] =
     _.map(_.show).through(text.encode(charset)).through(stdout)
 
-  /** Pipe that converts a stream of bytes to a stream that will emit a single `java.io.InputStream`,
-    * that is closed whenever the resulting stream terminates.
-    *
-    * If the `close` of resulting input stream is invoked manually, then this will await until the
-    * original stream completely terminates.
-    *
-    * Because all `InputStream` methods block (including `close`), the resulting `InputStream`
-    * should be consumed on a different thread pool than the one that is backing the effect.
-    *
-    * Note that the implementation is not thread safe -- only one thread is allowed at any time
-    * to operate on the resulting `java.io.InputStream`.
-    */
-  def toInputStream[F[_]: Async]: Pipe[F, Byte, InputStream] =
-    source => Stream.resource(toInputStreamResource(source))
-
-  /** Like [[toInputStream]] but returns a `Resource` rather than a single element stream.
-    */
-  def toInputStreamResource[F[_]: Async](
-      source: Stream[F, Byte]
-  ): Resource[F, InputStream] =
-    JavaInputOutputStream.toInputStream(source)
-
   // Using null instead of Option because null check is faster
   private lazy val vtExecutor: ExecutionContext = {
     val javaVersion: Int =