Get openZip working on KotlinNative (#1439)

swankjesse · web-flow · commit 20b83aaf698d · 2024-02-22T07:37:35.000-05:00
* Get openZip working on KotlinNative

* No assertk for wasmJs or wasmWasi

* Make okioRoot lazy
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -15,6 +15,9 @@ import org.jetbrains.dokka.gradle.DokkaTask
 import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension
 import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin
 import org.jetbrains.kotlin.gradle.targets.js.npm.tasks.KotlinNpmInstallTask
+import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest
+import org.jetbrains.kotlin.gradle.targets.jvm.tasks.KotlinJvmTest
+import org.jetbrains.kotlin.gradle.targets.native.tasks.KotlinNativeTest
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -246,3 +249,22 @@ plugins.withType<NodeJsRootPlugin> {
     args += "--ignore-engines"
   }
 }
+
+/**
+ * Set the `OKIO_ROOT` environment variable for tests to access it.
+ * https://publicobject.com/2023/04/16/read-a-project-file-in-a-kotlin-multiplatform-test/
+ */
+allprojects {
+  tasks.withType<KotlinJvmTest>().configureEach {
+    environment("OKIO_ROOT", rootDir)
+  }
+
+  tasks.withType<KotlinNativeTest>().configureEach {
+    environment("SIMCTL_CHILD_OKIO_ROOT", rootDir)
+    environment("OKIO_ROOT", rootDir)
+  }
+
+  tasks.withType<KotlinJsTest>().configureEach {
+    environment("OKIO_ROOT", rootDir.toString())
+  }
+}
diff --git a/okio-testing-support/build.gradle.kts b/okio-testing-support/build.gradle.kts
@@ -28,6 +28,10 @@ kotlin {
       }
     }
 
+    val zlibMain by creating {
+      dependsOn(commonMain)
+    }
+
     if (kmpJsEnabled) {
       val jsMain by getting {
         dependsOn(nonWasmMain)
@@ -36,6 +40,7 @@ kotlin {
 
     val jvmMain by getting {
       dependsOn(nonWasmMain)
+      dependsOn(zlibMain)
       dependencies {
         // On the JVM the kotlin-test library resolves to one of three implementations based on
         // which testing framework is in use. JUnit is used downstream, but Gradle can't know that
@@ -48,6 +53,7 @@ kotlin {
       createSourceSet("nativeMain", children = nativeTargets)
         .also { nativeMain ->
           nativeMain.dependsOn(nonWasmMain)
+          nativeMain.dependsOn(zlibMain)
         }
     }
 
diff --git a/okio-testing-support/src/commonMain/kotlin/okio/TestingCommon.kt b/okio-testing-support/src/commonMain/kotlin/okio/TestingCommon.kt
@@ -19,6 +19,7 @@ import kotlin.random.Random
 import kotlin.test.assertEquals
 import kotlin.time.Duration
 import okio.ByteString.Companion.toByteString
+import okio.Path.Companion.toPath
 
 fun Char.repeat(count: Int): String {
   return toString().repeat(count)
@@ -90,3 +91,9 @@ expect val FileSystem.allowSymlinks: Boolean
 expect val FileSystem.allowReadsWhileWriting: Boolean
 
 expect var FileSystem.workingDirectory: Path
+
+expect fun getEnv(name: String): String?
+
+val okioRoot: Path by lazy {
+  getEnv("OKIO_ROOT")!!.toPath()
+}
diff --git a/okio-testing-support/src/commonMain/resources/okio/zipfilesystem/empty.zip b/okio-testing-support/src/commonMain/resources/okio/zipfilesystem/empty.zip
diff --git a/okio-testing-support/src/jsMain/kotlin/okio/TestingJs.kt b/okio-testing-support/src/jsMain/kotlin/okio/TestingJs.kt
@@ -20,3 +20,6 @@ actual fun isBrowser(): Boolean {
 }
 
 actual fun isWasm() = false
+
+actual fun getEnv(name: String): String? =
+  js("globalThis.process.env[name]") as String?
diff --git a/okio-testing-support/src/jvmMain/kotlin/okio/TestingJvm.kt b/okio-testing-support/src/jvmMain/kotlin/okio/TestingJvm.kt
@@ -15,6 +15,10 @@
  */
 package okio
 
+actual val SYSTEM_FILE_SYSTEM = FileSystem.SYSTEM
+
 actual fun isBrowser() = false
 
 actual fun isWasm() = false
+
+actual fun getEnv(name: String): String? = System.getenv(name)
diff --git a/okio-testing-support/src/nativeMain/kotlin/okio/TestingNative.kt b/okio-testing-support/src/nativeMain/kotlin/okio/TestingNative.kt
@@ -15,6 +15,15 @@
  */
 package okio
 
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.toKString
+import platform.posix.getenv
+
+actual val SYSTEM_FILE_SYSTEM = FileSystem.SYSTEM
+
 actual fun isBrowser() = false
 
 actual fun isWasm() = false
+
+@OptIn(ExperimentalForeignApi::class)
+actual fun getEnv(name: String): String? = getenv(name)?.toKString()
diff --git a/okio-testing-support/src/wasmMain/kotlin/okio/TestingWasm.kt b/okio-testing-support/src/wasmMain/kotlin/okio/TestingWasm.kt
@@ -59,3 +59,5 @@ actual val FileSystem.allowReadsWhileWriting: Boolean
 actual var FileSystem.workingDirectory: Path
   get() = error("unexpected call")
   set(_) = error("unexpected call")
+
+actual fun getEnv(name: String): String? = error("unexpected call")
diff --git a/okio-testing-support/src/zlibMain/kotlin/okio/TestingZlib.kt b/okio-testing-support/src/zlibMain/kotlin/okio/TestingZlib.kt
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2024 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package okio
+
+expect val SYSTEM_FILE_SYSTEM: FileSystem
diff --git a/okio/build.gradle.kts b/okio/build.gradle.kts
@@ -97,6 +97,9 @@ kotlin {
 
     val zlibTest by creating {
       dependsOn(commonTest)
+      dependencies {
+        implementation(libs.test.assertk)
+      }
     }
 
     val jvmMain by getting {
diff --git a/okio/src/jvmMain/kotlin/okio/JvmOkio.kt b/okio/src/jvmMain/kotlin/okio/JvmOkio.kt
@@ -224,9 +224,6 @@ fun Sink.hashingSink(digest: MessageDigest): HashingSink = HashingSink(this, dig
  */
 fun Source.hashingSource(digest: MessageDigest): HashingSource = HashingSource(this, digest)
 
-@Throws(IOException::class)
-fun FileSystem.openZip(zipPath: Path): FileSystem = okio.internal.openZip(zipPath, this)
-
 fun ClassLoader.asResourceFileSystem(): FileSystem = ResourceFileSystem(this, indexEagerly = true)
 
 /**
diff --git a/okio/src/nativeMain/kotlin/okio/internal/-ZlibNative.kt b/okio/src/nativeMain/kotlin/okio/internal/-ZlibNative.kt
@@ -20,7 +20,7 @@ internal actual val DEFAULT_COMPRESSION: Int = platform.zlib.Z_DEFAULT_COMPRESSI
 
 /**
  * Roll our own date math because Kotlin doesn't include a built-in date math API, and the
- * kotlinx.datetime library doesn't offer a stable at this time.
+ * kotlinx.datetime library doesn't offer a stable release at this time.
  *
  * Also, we don't necessarily want to take on that dependency for Okio.
  *
diff --git a/okio/src/zlibMain/kotlin/okio/ZipFileSystem.kt b/okio/src/zlibMain/kotlin/okio/ZipFileSystem.kt
@@ -16,8 +16,6 @@
  */
 package okio
 
-import java.io.FileNotFoundException
-import java.util.zip.Inflater
 import okio.Path.Companion.toPath
 import okio.internal.COMPRESSION_METHOD_STORED
 import okio.internal.FixedLengthSource
diff --git a/okio/src/zlibMain/kotlin/okio/ZlibOkio.kt b/okio/src/zlibMain/kotlin/okio/ZlibOkio.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2014 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:JvmMultifileClass
+@file:JvmName("Okio")
+
+package okio
+
+import kotlin.jvm.JvmMultifileClass
+import kotlin.jvm.JvmName
+
+@Throws(IOException::class)
+fun FileSystem.openZip(zipPath: Path): FileSystem = okio.internal.openZip(zipPath, this)
diff --git a/okio/src/zlibMain/kotlin/okio/internal/FixedLengthSource.kt b/okio/src/zlibMain/kotlin/okio/internal/FixedLengthSource.kt
diff --git a/okio/src/zlibMain/kotlin/okio/internal/ZipEntry.kt b/okio/src/zlibMain/kotlin/okio/internal/ZipEntry.kt
diff --git a/okio/src/zlibMain/kotlin/okio/internal/ZipFiles.kt b/okio/src/zlibMain/kotlin/okio/internal/ZipFiles.kt
@@ -24,6 +24,7 @@ import okio.Path
 import okio.Path.Companion.toPath
 import okio.ZipFileSystem
 import okio.buffer
+import okio.use
 
 private const val LOCAL_FILE_HEADER_SIGNATURE = 0x4034b50
 private const val CENTRAL_FILE_HEADER_SIGNATURE = 0x2014b50
diff --git a/okio/src/zlibTest/kotlin/okio/ZipFileSystemTest.kt b/okio/src/zlibTest/kotlin/okio/ZipFileSystemTest.kt
@@ -15,20 +15,30 @@
  */
 package okio
 
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.containsExactlyInAnyOrder
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isGreaterThan
+import assertk.assertions.isLessThan
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import assertk.assertions.isTrue
+import kotlin.test.BeforeTest
+import kotlin.test.Test
 import kotlin.test.assertFailsWith
 import kotlinx.datetime.Instant
 import okio.ByteString.Companion.decodeHex
 import okio.ByteString.Companion.encodeUtf8
 import okio.Path.Companion.toPath
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.Before
-import org.junit.Test
 
 class ZipFileSystemTest {
-  private val fileSystem = FileSystem.SYSTEM
-  private var base = "../okio-testing-support/src/commonMain/resources/okio/zipfilesystem".toPath()
+  private val fileSystem = SYSTEM_FILE_SYSTEM
+  private var base = okioRoot / "okio-testing-support/src/commonMain/resources/okio/zipfilesystem"
 
-  @Before
+  @BeforeTest
   fun setUp() {
     fileSystem.createDirectory(base)
   }
@@ -83,7 +93,7 @@ class ZipFileSystemTest {
       .isEqualTo("Another file!")
 
     assertThat(zipFileSystem.list("/".toPath()))
-      .hasSameElementsAs(listOf("/hello.txt".toPath(), "/directory".toPath()))
+      .containsExactlyInAnyOrder("/hello.txt".toPath(), "/directory".toPath())
     assertThat(zipFileSystem.list("/directory".toPath()))
       .containsExactly("/directory/subdirectory".toPath())
     assertThat(zipFileSystem.list("/directory/subdirectory".toPath()))
@@ -112,7 +122,7 @@ class ZipFileSystemTest {
   fun zipWithDeflate() {
     val content = "Android\n".repeat(1000)
     val zipPath = base / "zipWithDeflate.zip"
-    assertThat(fileSystem.metadata(zipPath).size).isLessThan(content.length.toLong())
+    assertThat(fileSystem.metadata(zipPath).size).isNotNull().isLessThan(content.length.toLong())
     val zipFileSystem = fileSystem.openZip(zipPath)
 
     assertThat(zipFileSystem.read("a.txt".toPath()) { readUtf8() })
@@ -138,7 +148,7 @@ class ZipFileSystemTest {
   fun zipWithStore() {
     val content = "Android\n".repeat(1000)
     val zipPath = base / "zipWithStore.zip"
-    assertThat(fileSystem.metadata(zipPath).size).isGreaterThan(content.length.toLong())
+    assertThat(fileSystem.metadata(zipPath).size).isNotNull().isGreaterThan(content.length.toLong())
     val zipFileSystem = fileSystem.openZip(zipPath)
 
     assertThat(zipFileSystem.read("a.txt".toPath()) { readUtf8() })
@@ -524,8 +534,8 @@ class ZipFileSystemTest {
    * `META-INF/kotlin-gradle-statistics.kotlin_module`.
    *
    * We used to crash on duplicates, but they are common in practice so now we prefer the last
-   * entry. This behavior is consistent with both [java.util.zip.ZipFile] and
-   * [java.nio.file.FileSystem].
+   * entry. This behavior is consistent with both `java.util.zip.ZipFile` and
+   * `java.nio.file.FileSystem`.
    *
    * ```
    * echo "This is the first hello.txt" > hello.txt

Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,10 @@ kotlin {`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`
	`31`	`+ val zlibMain by creating {`
	`32`	`+ dependsOn(commonMain)`
	`33`	`+ }`
	`34`	`+`
`31`	`35`	`if (kmpJsEnabled) {`
`32`	`36`	`val jsMain by getting {`
`33`	`37`	`dependsOn(nonWasmMain)`
`@@ -36,6 +40,7 @@ kotlin {`
`36`	`40`
`37`	`41`	`val jvmMain by getting {`
`38`	`42`	`dependsOn(nonWasmMain)`
	`43`	`+ dependsOn(zlibMain)`
`39`	`44`	`dependencies {`
`40`	`45`	`// On the JVM the kotlin-test library resolves to one of three implementations based on`
`41`	`46`	`// which testing framework is in use. JUnit is used downstream, but Gradle can't know that`
`@@ -48,6 +53,7 @@ kotlin {`
`48`	`53`	`createSourceSet("nativeMain", children = nativeTargets)`
`49`	`54`	`.also { nativeMain ->`
`50`	`55`	`nativeMain.dependsOn(nonWasmMain)`
	`56`	`+ nativeMain.dependsOn(zlibMain)`
`51`	`57`	`}`
`52`	`58`	`}`
`53`	`59`
Original file line number	Diff line number	Diff line change
`@@ -20,3 +20,6 @@ actual fun isBrowser(): Boolean {`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`actual fun isWasm() = false`
	`23`	`+`
	`24`	`+actual fun getEnv(name: String): String? =`
	`25`	`+ js("globalThis.process.env[name]") as String?`
Original file line number	Diff line number	Diff line change
`@@ -97,6 +97,9 @@ kotlin {`
`97`	`97`
`98`	`98`	`val zlibTest by creating {`
`99`	`99`	`dependsOn(commonTest)`
	`100`	`+ dependencies {`
	`101`	`+ implementation(libs.test.assertk)`
	`102`	`+ }`
`100`	`103`	`}`
`101`	`104`
`102`	`105`	`val jvmMain by getting {`