File reading now works on Native

Author: ekrich

sconfig/jvm-native/src/test/scala/org/ekrich/config/impl/ConfigFactoryJvmNativeTest.scala sconfig/jvm-native/src/test/scala/org/ekrich/config/impl/ConfigFactoryDocumentTest.scala

@@ -3,6 +3,6 @@ package org.ekrich.config.impl
 // import org.junit.Assert._
 // import org.junit.Test
 
-class ConfigFactoryJvmNativeTest {
+class ConfigFactoryDocumentTest {
   // Empty for now - Scala.js has parody with Scala Native for now
 }

sconfig/jvm/src/test/scala/org/ekrich/config/impl/ConfigDocumentFactoryJvmTest.scala

@@ -15,7 +15,7 @@ class ConfigDocumentFactoryJvmTest extends TestUtils {
     val configDocument =
       ConfigDocumentFactory.parseFile(resourceFile("/test03.conf"))
     val fileReader = new BufferedReader(
-      new FileReader("src/test/resources/test03.conf")
+      new FileReader(resourceFile("/test03.conf"))
     )
     var line = fileReader.readLine()
     val sb = new StringBuilder()

sconfig/jvm-native/src/test/scala/org/ekrich/config/impl/FileUtils.scala sconfig/jvm/src/test/scala/org/ekrich/config/impl/FileUtils.scala

@@ -14,7 +14,9 @@ class URL(from: String) {
 
   def toURI(): java.net.URI = ???
 
-  def toExternalForm(): java.lang.String = ???
+  def toExternalForm(): java.lang.String = from
+
+  override def toString(): java.lang.String = toExternalForm()
 
   // added
   def getFile(): String = ???

sconfig/native/src/main/scala/java/net/URL.scala

@@ -8,14 +8,14 @@ import org.junit.Test
 
 import FileUtils._
 
-class ConfigDocumentFactoryJvmTest extends TestUtils {
+class ConfigDocumentFactoryNativeTest extends TestUtils {
 
   @Test
   def configDocumentFileParse: Unit = {
     val configDocument =
       ConfigDocumentFactory.parseFile(resourceFile("/test03.conf"))
     val fileReader = new BufferedReader(
-      new FileReader("src/test/resources/test03.conf")
+      new FileReader(resourceFile("/test03.conf"))
     )
     var line = fileReader.readLine()
     val sb = new StringBuilder()

sconfig/native/src/test/scala/org/ekrich/config/impl/ConfigDocumentFactoryJvmTest.scala sconfig/native/src/test/scala/org/ekrich/config/impl/ConfigDocumentFactoryNativeTest.scala

@@ -0,0 +1,86 @@
+/**
+ * Copyright (C) 2011 Typesafe Inc. <http://typesafe.com>
+ */
+package org.ekrich.config.impl
+
+import java.io.File
+import java.util.Locale
+
+/**
+ * Extracted from TestUtils as they contain File and Path and are not useful on
+ * Scala.js
+ *
+ * Note: Some functions may only be used in this file so they could be made
+ * private.
+ */
+object FileUtils {
+  // Some functions duplicated in TestUtils
+
+  def isWindows: Boolean =
+    sys.props
+      .get("os.name")
+      .exists(_.toLowerCase(Locale.ROOT).contains("windows"))
+
+  def userDrive: String =
+    if (isWindows)
+      sys.props.get("user.dir").fold("")(_.takeWhile(_ != File.separatorChar))
+    else ""
+
+  val resourceDir = {
+    val f = new File("sconfig/native/src/test/resources")
+    if (!f.exists()) {
+      val here = new File(".").getAbsolutePath
+      throw new Exception(
+        s"""Tests must be run from the root project directory containing
+           | ${f.getPath()}, however the current directory is
+           | ${here}""".stripMargin
+      )
+    }
+    f
+  }
+
+  def resourceFile(filename: String): File =
+    new File(resourceDir, filename)
+
+  def jsonQuotedResourceFile(filename: String): String =
+    quoteJsonString(resourceFile(filename).toString)
+
+  def quoteJsonString(s: String): String =
+    ConfigImplUtil.renderJsonString(s)
+
+  def writeFile(f: File, content: String): Unit = {
+    val writer = new java.io.PrintWriter(f, "UTF-8")
+    writer.append(content)
+    writer.close()
+  }
+
+  def deleteRecursive(f: File): Unit = {
+    if (f.exists) {
+      if (f.isDirectory) {
+        val children = f.listFiles()
+        if (children ne null) {
+          for (c <- children)
+            deleteRecursive(c)
+        }
+      }
+      f.delete()
+    }
+  }
+
+  def withScratchDirectory[T](
+      testcase: String
+  )(body: File => T): Unit = {
+    val target = new File("target")
+    if (!target.isDirectory)
+      throw new RuntimeException(s"Expecting $target to exist")
+    val suffix = java.lang.Integer
+      .toHexString(java.util.concurrent.ThreadLocalRandom.current.nextInt)
+    val scratch = new File(target, s"$testcase-$suffix")
+    scratch.mkdirs()
+    try {
+      body(scratch)
+    } finally {
+      deleteRecursive(scratch)
+    }
+  }
+}

sconfig/native/src/test/scala/org/ekrich/config/impl/FileUtils.scala

@@ -4,28 +4,24 @@
 package org.ekrich.config.impl
 
 import org.junit.Assert._
-import org.ekrich.config.ConfigOrigin
+
 import java.io.Reader
 import java.io.StringReader
-import org.ekrich.config.ConfigParseOptions
-import org.ekrich.config.ConfigSyntax
-import org.ekrich.config.ConfigFactory
-import java.io.ByteArrayOutputStream
-import java.io.ObjectOutputStream
-import java.io.ByteArrayInputStream
-import java.io.ObjectInputStream
-import java.io.NotSerializableException
-import java.io.OutputStream
-import java.io.InputStream
-import scala.annotation.tailrec
 import java.net.URL
 import java.util.concurrent.Executors
 import java.util.concurrent.Callable
-import org.ekrich.config._
+
+import scala.annotation.tailrec
+import scala.jdk.CollectionConverters._
+import scala.language.implicitConversions
 import scala.reflect.ClassTag
 import scala.reflect.classTag
-import scala.jdk.CollectionConverters._
-import language.implicitConversions
+
+import org.ekrich.config._
+import org.ekrich.config.ConfigOrigin
+import org.ekrich.config.ConfigFactory
+import org.ekrich.config.ConfigParseOptions
+import org.ekrich.config.ConfigSyntax
 
 abstract trait TestUtils {
   protected def intercept[E <: Throwable: ClassTag](block: => Any): E = {
@@ -151,20 +147,6 @@ abstract trait TestUtils {
     a
   }
 
-  private def copyViaSerialize(o: java.io.Serializable): AnyRef = {
-    val byteStream = new ByteArrayOutputStream()
-    val objectStream = new ObjectOutputStream(byteStream)
-    objectStream.writeObject(o)
-    objectStream.close()
-    val bytes = byteStream.toByteArray()
-    // outputStringLiteral(bytes) // uncomment to print
-    val inStream = new ByteArrayInputStream(bytes)
-    val inObjectStream = new ObjectInputStream(inStream)
-    val copy = inObjectStream.readObject()
-    inObjectStream.close()
-    copy
-  }
-
   def outputStringLiteral(bytes: Array[Byte]): Unit = {
     val hex = encodeLegibleBinary(bytes)
     outputStringLiteral(hex)
@@ -180,142 +162,6 @@ abstract trait TestUtils {
     }
   }
 
-  protected def checkSerializationCompat[T: ClassTag](
-      expectedHex: String,
-      o: T,
-      changedOK: Boolean = false
-  ): Unit = {
-    // be sure we can still deserialize the old one
-    val inStream = new ByteArrayInputStream(decodeLegibleBinary(expectedHex))
-    var failure: Option[Exception] = None
-    var inObjectStream: ObjectInputStream = null
-    val deserialized =
-      try {
-        inObjectStream = new ObjectInputStream(inStream) // this can throw too
-        inObjectStream.readObject()
-      } catch {
-        case e: Exception =>
-          failure = Some(e)
-          null
-      } finally {
-        if (inObjectStream != null)
-          inObjectStream.close()
-      }
-
-    val why = failure
-      .map({ e => ": " + e.getClass.getSimpleName + ": " + e.getMessage })
-      .getOrElse("")
-
-    val byteStream = new ByteArrayOutputStream()
-    val objectStream = new ObjectOutputStream(byteStream)
-    objectStream.writeObject(o)
-    objectStream.close()
-    val hex = encodeLegibleBinary(byteStream.toByteArray())
-    def showCorrectResult(): Unit = {
-      if (expectedHex != hex) {
-        System.err.println(
-          "Correct result literal for " + o.getClass.getSimpleName + " serialization:"
-        )
-        System.err.println(
-          "\"\" + "
-        ) // line up all the lines by using empty string on first line
-        outputStringLiteral(hex)
-      }
-    }
-
-    try {
-      assertEquals(
-        "Can no longer deserialize the old format of " + o.getClass.getSimpleName + why,
-        o,
-        deserialized
-      )
-      assertFalse(failure.isDefined) // should have thrown if we had a failure
-
-      if (!changedOK)
-        assertEquals(
-          o.getClass.getSimpleName + " serialization has changed (though we still deserialized the old serialization)",
-          expectedHex,
-          hex
-        )
-    } catch {
-      case e: Throwable =>
-        showCorrectResult()
-        throw e
-    }
-  }
-
-  // no ObjectOutputStream / Serialization on Scala.js
-  protected def checkNotSerializable(o: AnyRef): Unit = {
-    val byteStream = new ByteArrayOutputStream()
-    val objectStream = new ObjectOutputStream(byteStream)
-    val e = intercept[NotSerializableException] {
-      objectStream.writeObject(o)
-    }
-    objectStream.close()
-  }
-
-  protected def checkSerializable[T: ClassTag](expectedHex: String, o: T): T = {
-    val t = checkSerializable(o)
-    checkSerializationCompat(expectedHex, o)
-    t
-  }
-
-  protected def checkSerializableOldFormat[T: ClassTag](
-      expectedHex: String,
-      o: T
-  ): T = {
-    val t = checkSerializable(o)
-    checkSerializationCompat(expectedHex, o, changedOK = true)
-    t
-  }
-
-  protected def checkSerializableNoMeaningfulEquals[T: ClassTag](o: T): T = {
-    assertTrue(
-      o.getClass.getSimpleName + " not an instance of Serializable",
-      o.isInstanceOf[java.io.Serializable]
-    )
-
-    val a = o.asInstanceOf[java.io.Serializable]
-
-    val b =
-      try {
-        copyViaSerialize(a)
-      } catch {
-        case nf: ClassNotFoundException =>
-          throw new AssertionError(
-            "failed to make a copy via serialization, " +
-              "possibly caused by http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6446627",
-            nf
-          )
-        case e: Exception =>
-          e.printStackTrace(System.err)
-          throw new AssertionError("failed to make a copy via serialization", e)
-      }
-
-    assertTrue(
-      "deserialized type " + b.getClass.getSimpleName + " doesn't match serialized type " + a.getClass.getSimpleName,
-      classTag[T].runtimeClass.isAssignableFrom(b.getClass)
-    )
-
-    b.asInstanceOf[T]
-  }
-
-  protected def checkSerializable[T: ClassTag](o: T): T = {
-    checkEqualObjects(o, o)
-
-    assertTrue(
-      o.getClass.getSimpleName + " not an instance of Serializable",
-      o.isInstanceOf[java.io.Serializable]
-    )
-
-    val b = checkSerializableNoMeaningfulEquals(o)
-
-    checkEqualObjects(o, b)
-    checkEqualOrigins(o, b)
-
-    b
-  }
-
   // origin() is not part of value equality but is serialized, so
   // we check it separately
   protected def checkEqualOrigins[T](a: T, b: T): Unit = (a, b) match {
@@ -984,33 +830,4 @@ abstract trait TestUtils {
       problems.size
     )
   }
-
-  protected def checkSerializableWithCustomSerializer[T: ClassTag](o: T): T = {
-    val byteStream = new ByteArrayOutputStream()
-    val objectStream = new CustomObjectOutputStream(byteStream)
-    objectStream.writeObject(o)
-    objectStream.close()
-    val inStream = new ByteArrayInputStream(byteStream.toByteArray)
-    val inObjectStream = new CustomObjectInputStream(inStream)
-    val copy = inObjectStream.readObject()
-    inObjectStream.close()
-    copy.asInstanceOf[T]
-  }
-
-  class CustomObjectOutputStream(out: OutputStream)
-      extends ObjectOutputStream(out) {
-    override def writeUTF(str: String): Unit = {
-      val bytes = str.getBytes
-      writeLong(bytes.length)
-      write(bytes)
-    }
-  }
-
-  class CustomObjectInputStream(in: InputStream) extends ObjectInputStream(in) {
-    override def readUTF(): String = {
-      val bytes = new Array[Byte](readLong().toByte)
-      read(bytes)
-      new String(bytes)
-    }
-  }
 }

sconfig/native/src/test/scala/org/ekrich/config/impl/TestUtils.scala

@@ -30,6 +30,9 @@ object SimpleConfigOrigin {
   private[impl] def newFile(filename: String): SimpleConfigOrigin = {
     var url: String = null
     try {
+      // TODO: Change to Use URI - string bases URL is the same anyway.
+      // eventually we could change public API to use URI and support
+      // JS and Native to use different fetching libraries
       val uri = new File(filename).toURI()
       url = new PlatformUri(uri).toURL().toExternalForm()
     } catch {