Decode env variables in WASI tests (#1773)

* Decode env variables in WASI tests

Also delete the obsolete Instant and Clock shims necessary
because Wasi didn't have these types previously.

* Fix some build bugs

Author: swankjesse

okio-testing-support/build.gradle.kts

@@ -64,6 +64,11 @@ kotlin {
         .also { wasmMain ->
           wasmMain.dependsOn(commonMain)
         }
+      val wasmWasiMain by getting {
+        dependencies {
+          implementation(project(":okio-wasifilesystem"))
+        }
+      }
     }
   }
 }

okio-testing-support/src/commonMain/kotlin/okio/AbstractFileSystemTest.kt

@@ -25,9 +25,11 @@ import kotlin.test.assertFalse
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
 import kotlin.test.fail
+import kotlin.time.Clock
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Duration.Companion.seconds
+import kotlin.time.Instant
 import okio.ByteString.Companion.encodeUtf8
 import okio.ByteString.Companion.toByteString
 import okio.Path.Companion.toPath
@@ -2705,7 +2707,7 @@ abstract class AbstractFileSystemTest(
    */
   private fun Instant.minFileSystemTime(): Instant {
     val paddedInstant = minus(200.milliseconds)
-    return fromEpochSeconds(paddedInstant.epochSeconds)
+    return Instant.fromEpochSeconds(paddedInstant.epochSeconds)
   }
 
   /**
@@ -2720,7 +2722,7 @@ abstract class AbstractFileSystemTest(
    */
   private fun Instant.maxFileSystemTime(): Instant {
     val paddedInstant = plus(200.milliseconds)
-    return fromEpochSeconds(paddedInstant.plus(2.seconds).epochSeconds)
+    return Instant.fromEpochSeconds(paddedInstant.plus(2.seconds).epochSeconds)
   }
 
   /**

okio-testing-support/src/commonMain/kotlin/okio/FakeClock.kt

@@ -15,10 +15,12 @@
  */
 package okio
 
+import kotlin.time.Clock
 import kotlin.time.Duration
+import kotlin.time.Instant
 
 class FakeClock : Clock {
-  var time = fromEpochSeconds(1609459200L) // 2021-01-01T00:00:00Z
+  var time = Instant.fromEpochSeconds(1609459200L) // 2021-01-01T00:00:00Z
 
   override fun now() = time
 

okio-testing-support/src/commonMain/kotlin/okio/TestingCommon.kt

@@ -17,7 +17,7 @@ package okio
 
 import kotlin.random.Random
 import kotlin.test.assertEquals
-import kotlin.time.Duration
+import kotlin.time.Instant
 import okio.ByteString.Companion.toByteString
 import okio.Path.Companion.toPath
 
@@ -45,47 +45,21 @@ expect fun isWasm(): Boolean
 val FileMetadata.createdAt: Instant?
   get() {
     val createdAt = createdAtMillis ?: return null
-    return fromEpochMilliseconds(createdAt)
+    return Instant.fromEpochMilliseconds(createdAt)
   }
 
 val FileMetadata.lastModifiedAt: Instant?
   get() {
     val lastModifiedAt = lastModifiedAtMillis ?: return null
-    return fromEpochMilliseconds(lastModifiedAt)
+    return Instant.fromEpochMilliseconds(lastModifiedAt)
   }
 
 val FileMetadata.lastAccessedAt: Instant?
   get() {
     val lastAccessedAt = lastAccessedAtMillis ?: return null
-    return fromEpochMilliseconds(lastAccessedAt)
+    return Instant.fromEpochMilliseconds(lastAccessedAt)
   }
 
-/*
- * This file contains some declarations from kotlinx.datetime used by [AbstractFileSystemTest], but
- * that we can't use because that library isn't yet available for WASM. We should delete these when
- * WASM is supported in kotlinx.datetime.
- */
-
-expect interface Clock {
-  fun now(): Instant
-}
-
-expect class Instant : Comparable<Instant> {
-  val epochSeconds: Long
-
-  operator fun plus(duration: Duration): Instant
-
-  operator fun minus(duration: Duration): Instant
-
-  override operator fun compareTo(other: Instant): Int
-}
-
-expect fun fromEpochSeconds(
-  epochSeconds: Long,
-): Instant
-
-expect fun fromEpochMilliseconds(epochMilliseconds: Long): Instant
-
 expect val FileSystem.isFakeFileSystem: Boolean
 
 expect val FileSystem.allowSymlinks: Boolean

okio-testing-support/src/nonWasmMain/kotlin/okio/TestingNonWasm.kt

@@ -17,18 +17,6 @@ package okio
 
 import okio.fakefilesystem.FakeFileSystem
 
-actual typealias Clock = kotlin.time.Clock
-
-actual typealias Instant = kotlin.time.Instant
-
-actual fun fromEpochSeconds(
-  epochSeconds: Long,
-) = Instant.fromEpochSeconds(epochSeconds)
-
-actual fun fromEpochMilliseconds(
-  epochMilliseconds: Long,
-) = Instant.fromEpochMilliseconds(epochMilliseconds)
-
 actual val FileSystem.isFakeFileSystem: Boolean
   get() = this is FakeFileSystem
 

okio-testing-support/src/wasmJsMain/kotlin/okio/WasiEnvWasmJs.kt

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2026 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
+
+actual fun getEnv(name: String): String? = error("unexpected call")

okio-testing-support/src/wasmMain/kotlin/okio/TestingWasm.kt

@@ -13,40 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+@file:OptIn(ExperimentalTime::class)
+
 package okio
 
-import kotlin.time.Duration
+import kotlin.time.ExperimentalTime
 
 actual fun isBrowser() = false
 
 actual fun isWasm() = true
 
-actual interface Clock {
-  actual fun now(): Instant
-}
-
-actual class Instant(
-  private val epochMilliseconds: Long,
-) : Comparable<Instant> {
-  actual val epochSeconds: Long
-    get() = epochMilliseconds / 1_000L
-
-  actual operator fun plus(duration: Duration) =
-    Instant(epochMilliseconds + duration.inWholeMilliseconds)
-
-  actual operator fun minus(duration: Duration) =
-    Instant(epochMilliseconds - duration.inWholeMilliseconds)
-
-  actual override fun compareTo(other: Instant) =
-    epochMilliseconds.compareTo(other.epochMilliseconds)
-}
-
-actual fun fromEpochSeconds(epochSeconds: Long) =
-  Instant(epochSeconds * 1_000L)
-
-actual fun fromEpochMilliseconds(epochMilliseconds: Long) =
-  Instant(epochMilliseconds)
-
 actual val FileSystem.isFakeFileSystem: Boolean
   get() = false
 
@@ -59,5 +35,3 @@ 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")

okio-testing-support/src/wasmWasiMain/kotlin/okio/WasiClock.kt

@@ -15,6 +15,8 @@
  */
 package okio
 
+import kotlin.time.Clock
+import kotlin.time.Instant
 import kotlin.wasm.unsafe.UnsafeWasmMemoryApi
 import kotlin.wasm.unsafe.withScopedMemoryAllocator
 import okio.internal.preview1.clock_time_get
@@ -33,7 +35,11 @@ object WasiClock : Clock {
       if (errno != 0) throw IllegalStateException("failed to get now: $errno")
 
       val nanos = returnPointer.loadLong()
-      return Instant(epochMilliseconds = nanos / 1_000_000L)
+      val seconds = nanos / 1_000_000_000L
+      return Instant.fromEpochSeconds(
+        epochSeconds = seconds,
+        nanosecondAdjustment = (nanos - seconds * 1_000_000_000L).toInt(),
+      )
     }
   }
 }

okio-testing-support/src/wasmWasiMain/kotlin/okio/WasiEnv.kt

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2026 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:Suppress(
+  "INVISIBLE_REFERENCE",
+)
+
+package okio
+
+import kotlin.wasm.unsafe.Pointer
+import kotlin.wasm.unsafe.UnsafeWasmMemoryApi
+import kotlin.wasm.unsafe.withScopedMemoryAllocator
+import okio.internal.ErrnoException
+import okio.internal.preview1.environ_get
+import okio.internal.preview1.environ_sizes_get
+import okio.internal.readString
+
+@OptIn(UnsafeWasmMemoryApi::class)
+val env: Map<String, String> by lazy {
+  withScopedMemoryAllocator { allocator ->
+    val entryCountPointer = allocator.allocate(4)
+    val byteCountPointer = allocator.allocate(4)
+    val sizesGetErrno = environ_sizes_get(
+      returnEntryCountPointer = entryCountPointer.address.toInt(),
+      returnByteCountPointer = byteCountPointer.address.toInt(),
+    )
+    if (sizesGetErrno != 0) throw ErrnoException(sizesGetErrno.toShort())
+
+    val entryCount = entryCountPointer.loadInt()
+    val byteCount = byteCountPointer.loadInt()
+
+    val entryPointersPointer = allocator.allocate(entryCount * 4)
+    val entryBytesPointer = allocator.allocate(byteCount)
+    val getErrno = environ_get(
+      entryPointersPointer.address.toInt(),
+      entryBytesPointer.address.toInt(),
+    )
+    if (getErrno != 0) throw ErrnoException(getErrno.toShort())
+
+    buildMap {
+      for (i in 0 until entryCount) {
+        val entryPointer = Pointer((entryPointersPointer + i * 4).loadInt().toUInt())
+        val entryString = entryPointer.readNullTerminated()
+        val eq = entryString.indexOf('=')
+        if (eq != -1) {
+          put(entryString.take(eq), entryString.substring(eq + 1))
+        }
+      }
+    }
+  }
+}
+
+@OptIn(UnsafeWasmMemoryApi::class)
+internal fun Pointer.readNullTerminated(): String {
+  var byteCount = 0
+  while ((this + byteCount).loadByte().toInt() != 0) {
+    byteCount++
+  }
+  return readString(byteCount)
+}
+
+actual fun getEnv(name: String) = env[name]

okio-testing-support/src/wasmWasiMain/kotlin/okio/internal/preview1/Preview1Env.kt

@@ -0,0 +1,29 @@
+// Copyright 2019-2023 the Contributors to the WASI Specification
+// This file is adapted from the WASI preview1 spec here:
+// https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/docs.md
+
+package okio.internal.preview1
+
+/**
+ * environ_sizes_get() -> Result<(size, size), errno>
+ *
+ * Return environment variable data sizes.
+ */
+@WasmImport("wasi_snapshot_preview1", "environ_sizes_get")
+internal external fun environ_sizes_get(
+  returnEntryCountPointer: Int,
+  returnByteCountPointer: Int,
+): Int // should be Short??
+
+/**
+ * environ_get(environ: Pointer<Pointer<u8>>, environ_buf: Pointer<u8>) -> Result<(), errno>
+ *
+ * Read environment variable data.
+ * The sizes of the buffers should match that returned by [`environ_sizes_get`](#environ_sizes_get).
+ * Key/value pairs are expected to be joined with `=`s, and terminated with `\0`s.
+ */
+@WasmImport("wasi_snapshot_preview1", "environ_get")
+internal external fun environ_get(
+  environ: Int,
+  environ_buf: Int,
+): Int // should be Short??