Support obtaining the system timezone on old Debian-based distributions

core/build.gradle.kts

@@ -221,12 +221,23 @@ kotlin {
                 runtimeOnly(project(":kotlinx-datetime-zoneinfo"))
             }
         }
+
+        val jvmTest by getting {
+            dependencies {
+                implementation("org.testcontainers:testcontainers:1.19.7")
+                implementation("org.testcontainers:junit-jupiter:1.19.7")
+                implementation("org.junit.jupiter:junit-jupiter-api:5.10.2")
+                runtimeOnly("org.junit.jupiter:junit-jupiter-engine:5.10.2")
+                implementation("ch.qos.logback:logback-classic:1.2.13")
+            }
+        }
     }
 }
 
 tasks {
     val jvmTest by existing(Test::class) {
         // maxHeapSize = "1024m"
+        useJUnitPlatform()
     }
 
     val compileJavaModuleInfo by registering(JavaCompile::class) {

core/jvm/test/testcontainers/Dockerfile

@@ -0,0 +1,10 @@
+FROM --platform=linux/arm64 ubuntu:24.04
+
+RUN apt-get update && apt-get install -y tzdata
+
+ENV INSIDE_TESTCONTAINERS=true
+
+# 4: Arctic/Longyearbyen
+RUN echo 4 | dpkg-reconfigure tzdata
+
+WORKDIR /app

core/jvm/test/testcontainers/TimeZoneConfigurationTest.kt

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2019-2025 JetBrains s.r.o. and contributors.
+ * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
+ */
+
+package testcontainers
+
+import org.junit.jupiter.api.BeforeAll
+import org.testcontainers.junit.jupiter.Container
+import org.testcontainers.junit.jupiter.Testcontainers
+import org.junit.jupiter.api.Test
+import org.slf4j.LoggerFactory
+import org.testcontainers.containers.Container.ExecResult
+
+@Testcontainers
+class TimeZoneConfigurationTest {
+
+    @Container
+    private val container = createTimezoneTestContainer()
+
+    @Test
+    fun defaultTimeZoneTest() {
+        assertExecSuccess(container.execDefaultTimeZoneTest())
+    }
+
+    @Test
+    fun debianCopyTimeZoneTest() {
+        assertExecSuccess(container.execDebianCopyTimeZoneTest())
+    }
+
+    @Test
+    fun timezoneMismatchTest() {
+        assertExecSuccess(container.execTimezoneMismatchTest())
+    }
+
+    @Test
+    fun missingEtcTimezoneTest() {
+        assertExecSuccess(container.execMissingEtcTimezoneTest())
+    }
+
+    @Test
+    fun allTimeZoneFilesMissingTest() {
+        assertExecSuccess(container.execAllTimeZoneFilesMissingTest())
+    }
+
+    @Test
+    fun symlinkTimeZoneTest() {
+        assertExecSuccess(container.execSymlinkTimeZoneTest())
+    }
+
+    @Test
+    fun invalidTimezoneFormatTest() {
+        assertExecSuccess(container.execInvalidTimezoneFormatTest())
+    }
+
+    @Test
+    fun commonTimeZoneTests() {
+        assertExecSuccess(container.execCommonTimeZoneTests())
+    }
+
+    private fun assertExecSuccess(execResult: ExecResult) {
+        logger.info("Container stdout:\n${execResult.stdout}")
+        logger.info("Container stderr:\n${execResult.stderr}")
+        logger.info("Container exit code: ${execResult.exitCode}")
+
+        if (execResult.exitCode != 0) {
+            throw AssertionError(
+                """
+                |Command execution failed with exit code ${execResult.exitCode}.
+                |Stdout:
+                |${execResult.stdout}
+                |Stderr:
+                |${execResult.stderr}
+                """.trimMargin()
+            )
+        }
+    }
+
+    companion object {
+        private val logger = LoggerFactory.getLogger(TimeZoneConfigurationTest::class.java)
+
+        @JvmStatic
+        @BeforeAll
+        fun buildTestBinary() {
+            logger.info("Building test binary...")
+
+            val process = ProcessBuilder()
+                .command("../gradlew", "linkDebugTestLinuxArm64")
+                .redirectErrorStream(true)
+                .start()
+
+            process.inputStream.bufferedReader().use { reader ->
+                reader.lines().forEach { line ->
+                    logger.info("Build: {}", line)
+                }
+            }
+
+            val exitCode = process.waitFor()
+            if (exitCode != 0) {
+                throw IllegalStateException("Failed to build test binary: exit code $exitCode")
+            }
+
+            logger.info("Test binary built successfully")
+        }
+    }
+}

core/jvm/test/testcontainers/TimezoneTestContainer.kt

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2019-2025 JetBrains s.r.o. and contributors.
+ * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
+ */
+
+package testcontainers
+
+import org.testcontainers.containers.BindMode
+import org.testcontainers.containers.Container.ExecResult
+import org.testcontainers.containers.GenericContainer
+import org.testcontainers.images.builder.ImageFromDockerfile
+import java.nio.file.Path
+import java.nio.file.Paths
+
+class TimezoneTestContainer(dockerfilePath: Path, binaryDir: String, imageName: String) :
+    GenericContainer<TimezoneTestContainer>(ImageFromDockerfile(imageName).withDockerfile(dockerfilePath)) {
+
+    init {
+        withCommand("tail -f /dev/null")
+        withFileSystemBind(binaryDir, "/app", BindMode.READ_WRITE)
+    }
+
+    fun execDefaultTimeZoneTest(): ExecResult {
+        return execTest("kotlinx.datetime.test.TimeZoneLinuxNativeTest.defaultTimeZoneTest")
+    }
+
+    fun execDebianCopyTimeZoneTest(): ExecResult {
+        exec("rm /etc/localtime")
+        exec("cp /usr/share/zoneinfo/Europe/Berlin /etc/localtime")
+        exec("echo 'Europe/Berlin' > /etc/timezone")
+        return execTest("kotlinx.datetime.test.TimeZoneLinuxNativeTest.debianCopyTimeZoneTest")
+    }
+
+    fun execTimezoneMismatchTest(): ExecResult {
+        exec("rm -f /etc/localtime")
+        exec("cp /usr/share/zoneinfo/Europe/Berlin /etc/localtime")
+        exec("echo 'Europe/Paris' > /etc/timezone")
+        return execTest("kotlinx.datetime.test.TimeZoneLinuxNativeTest.timezoneMismatchTest")
+    }
+
+    fun execMissingEtcTimezoneTest(): ExecResult {
+        exec("rm -f /etc/timezone")
+        return execTest("kotlinx.datetime.test.TimeZoneLinuxNativeTest.missingEtcTimezoneTest")
+    }
+
+    fun execAllTimeZoneFilesMissingTest(): ExecResult {
+        exec("rm -f /etc/localtime")
+        exec("rm -f /etc/timezone")
+        return execTest("kotlinx.datetime.test.TimeZoneLinuxNativeTest.allTimeZoneFilesMissingTest")
+    }
+
+    fun execSymlinkTimeZoneTest(): ExecResult {
+        exec("rm -f /etc/localtime")
+        exec("ln -sf /usr/share/zoneinfo/Europe/Paris /etc/localtime")
+        exec("echo 'Europe/Paris' > /etc/timezone")
+        return execTest("kotlinx.datetime.test.TimeZoneLinuxNativeTest.symlinkTimeZoneTest")
+    }
+
+    fun execInvalidTimezoneFormatTest(): ExecResult {
+        exec("rm -f /etc/localtime")
+        exec("cp /usr/share/zoneinfo/Europe/Berlin /etc/localtime")
+        exec("echo 'Invalid/Timezone/Format' > /etc/timezone")
+        return execTest("kotlinx.datetime.test.TimeZoneLinuxNativeTest.invalidTimezoneFormatTest")
+    }
+
+    fun execCommonTimeZoneTests(): ExecResult {
+        exec("rm -f /etc/localtime")
+        exec("cp /usr/share/zoneinfo/$(cat /etc/timezone) /etc/localtime")
+        return execTest("kotlinx.datetime.test.TimeZoneTest.*")
+    }
+
+    private fun execTest(testFilter: String): ExecResult =
+        exec("chmod +x /app/test.kexe && /app/test.kexe --ktest_filter=$testFilter")
+
+    private fun exec(command: String): ExecResult = execInContainer("bash", "-c", command)
+}
+
+fun createTimezoneTestContainer(): TimezoneTestContainer {
+    return TimezoneTestContainer(
+        Paths.get("./jvm/test/testcontainers/Dockerfile"),
+        "./build/bin/linuxArm64/debugTest/",
+        "ubuntu-arctic-longyearbyen"
+    )
+}

core/jvm/testResources/logback-test.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.testcontainers" level="INFO"/>
+    <logger name="com.github.dockerjava" level="WARN"/>
+    <logger name="testcontainers" level="DEBUG"/>
+
+    <root level="INFO">
+        <appender-ref ref="CONSOLE" />
+    </root>
+</configuration>

core/linux/src/internal/TimeZoneNative.kt

@@ -5,6 +5,8 @@
 
 package kotlinx.datetime.internal
 
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.toKString
 import kotlinx.datetime.IllegalTimeZoneException
 import kotlinx.datetime.TimeZone
 
@@ -16,10 +18,40 @@ internal actual fun getAvailableZoneIds(): Set<String> =
 
 private val tzdb = runCatching { TzdbOnFilesystem() }
 
+@OptIn(ExperimentalForeignApi::class)
+private fun getTimezoneFromEtcTimezone(): String? {
+    val timezoneContent = Path.fromString("/etc/timezone").readBytes()?.toKString()?.trim() ?: return null
+    val zoneId = chaseSymlinks("/usr/share/zoneinfo/$timezoneContent")
+        ?.splitTimeZonePath()?.second?.toString()
+        ?: return null
+
+    val zoneInfoBytes = Path.fromString("/usr/share/zoneinfo/$zoneId").readBytes() ?: return null
+    val localtimeBytes = Path.fromString("/etc/localtime").readBytes() ?: return null
+
+    if (!localtimeBytes.contentEquals(zoneInfoBytes)) {
+        val displayTimezone = when (timezoneContent) {
+            zoneId -> "'$zoneId'"
+            else -> "'$timezoneContent' (resolved to '$zoneId')"
+        }
+        throw IllegalTimeZoneException(
+            "Timezone mismatch: /etc/timezone specifies $displayTimezone " +
+                    "but /etc/localtime content differs from /usr/share/zoneinfo/$zoneId"
+        )
+    }
+
+    return zoneId
+}
+
 internal actual fun currentSystemDefaultZone(): Pair<String, TimeZone?> {
-    // according to https://www.man7.org/linux/man-pages/man5/localtime.5.html, when there is no symlink, UTC is used
     val zonePath = currentSystemTimeZonePath ?: return "Z" to null
-    val zoneId = zonePath.splitTimeZonePath()?.second?.toString()
-        ?: throw IllegalTimeZoneException("Could not determine the timezone ID that `$zonePath` corresponds to")
-    return zoneId to null
-}
+
+    zonePath.splitTimeZonePath()?.second?.toString()?.let { zoneId ->
+        return zoneId to null
+    }
+
+    getTimezoneFromEtcTimezone()?.let { zoneId ->
+        return zoneId to null
+    }
+
+    throw IllegalTimeZoneException("Could not determine the timezone ID that `$zonePath` corresponds to")
+}

core/linux/test/TestcontainersSupport.kt

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2019-2025 JetBrains s.r.o. and contributors.
+ * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.datetime.test
+
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.toKString
+import platform.posix.getenv
+
+object Testcontainers {
+
+    @OptIn(ExperimentalForeignApi::class)
+    val available: Boolean
+        get() = getenv("INSIDE_TESTCONTAINERS")?.toKString()?.toBoolean() == true
+
+    inline fun runIfAvailable(block: () -> Unit) {
+        if (available) block() else println("[----------] Skipping test that requires testcontainers...")
+    }
+}