[K/N][Tests] Move threadStates tests to common codegen/box folder

^KT-61259

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java

@@ -6302,6 +6302,16 @@ public class FirLightTreeBlackBoxCodegenTestGenerated extends AbstractFirLightTr
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/packages"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
             }
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/cinterop/threadStates")
+        @TestDataPath("$PROJECT_ROOT")
+        public class ThreadStates {
+            @Test
+            public void testAllFilesPresentInThreadStates() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/threadStates"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+            }
+        }
     }
 
     @Nested

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenWithIrFakeOverrideGeneratorTestGenerated.java

@@ -6302,6 +6302,16 @@ public class FirLightTreeBlackBoxCodegenWithIrFakeOverrideGeneratorTestGenerated
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/packages"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
             }
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/cinterop/threadStates")
+        @TestDataPath("$PROJECT_ROOT")
+        public class ThreadStates {
+            @Test
+            public void testAllFilesPresentInThreadStates() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/threadStates"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+            }
+        }
     }
 
     @Nested

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java

@@ -6302,6 +6302,16 @@ public class FirPsiBlackBoxCodegenTestGenerated extends AbstractFirPsiBlackBoxCo
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/packages"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
             }
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/cinterop/threadStates")
+        @TestDataPath("$PROJECT_ROOT")
+        public class ThreadStates {
+            @Test
+            public void testAllFilesPresentInThreadStates() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/threadStates"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+            }
+        }
     }
 
     @Nested

compiler/testData/codegen/box/cinterop/threadStates/callback.kt

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+// TARGET_BACKEND: NATIVE
+// NATIVE_STANDALONE
+// FREE_COMPILER_ARGS: -opt-in=kotlin.native.internal.InternalForKotlinNative
+// MODULE: cinterop
+// FILE: threadStates.def
+language = C
+---
+void assertNativeThreadState();
+
+void runCallback(void(*callback)(void)) {
+    assertNativeThreadState();
+    callback();
+    assertNativeThreadState();
+}
+
+// FILE: threadStates.cpp
+#include <stdio.h>
+#include <stdlib.h>
+
+// Implemented in the runtime for test purposes.
+extern "C" bool Kotlin_Debugging_isThreadStateNative();
+
+extern "C" void assertNativeThreadState() {
+    if (!Kotlin_Debugging_isThreadStateNative()) {
+        printf("Incorrect thread state. Expected native thread state.");
+        abort();
+    }
+}
+
+// MODULE: main(cinterop)
+// FILE: main.kt
+@file:OptIn(kotlin.native.runtime.NativeRuntimeApi::class, kotlinx.cinterop.ExperimentalForeignApi::class)
+
+import kotlin.native.runtime.Debugging
+import kotlin.test.*
+import kotlinx.cinterop.*
+import threadStates.*
+
+fun box(): String {
+    runCallback(staticCFunction { ->
+        assertRunnableThreadState()
+    })
+    assertRunnableThreadState()
+    return "OK"
+}
+
+fun assertRunnableThreadState() {
+    assertTrue(Debugging.isThreadStateRunnable)
+}

compiler/testData/codegen/box/cinterop/threadStates/callbackOnSeparateThread.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+// TARGET_BACKEND: NATIVE
+// NATIVE_STANDALONE
+// FREE_COMPILER_ARGS: -opt-in=kotlin.native.internal.InternalForKotlinNative
+// MODULE: cinterop
+// FILE: threadStates.def
+language = C
+---
+void runInNewThread(void(*callback)(void));
+
+// FILE: threadStates.cpp
+#include <thread>
+
+extern "C" void runInNewThread(void(*callback)(void)) {
+    std::thread t([callback]() {
+        callback();
+    });
+    t.join();
+}
+
+// MODULE: main(cinterop)
+// FILE: main.kt
+@file:OptIn(kotlin.native.runtime.NativeRuntimeApi::class, kotlinx.cinterop.ExperimentalForeignApi::class)
+
+import kotlin.native.runtime.Debugging
+import kotlin.test.*
+import kotlinx.cinterop.*
+import threadStates.*
+
+fun box(): String {
+    runInNewThread(staticCFunction { ->
+        assertRunnableThreadState()
+    })
+    return "OK"
+}
+
+fun assertRunnableThreadState() {
+    assertTrue(Debugging.isThreadStateRunnable)
+}

compiler/testData/codegen/box/cinterop/threadStates/callbackWithException.kt

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+// TARGET_BACKEND: NATIVE
+// NATIVE_STANDALONE
+// FREE_COMPILER_ARGS: -opt-in=kotlin.native.internal.InternalForKotlinNative
+// MODULE: cinterop
+// FILE: threadStates.def
+language = C
+---
+void assertNativeThreadState();
+
+void runCallback(void(*callback)(void)) {
+    assertNativeThreadState();
+    callback();
+    assertNativeThreadState();
+}
+
+// FILE: threadStates.cpp
+#include <stdio.h>
+#include <stdlib.h>
+
+// Implemented in the runtime for test purposes.
+extern "C" bool Kotlin_Debugging_isThreadStateNative();
+
+extern "C" void assertNativeThreadState() {
+    if (!Kotlin_Debugging_isThreadStateNative()) {
+        printf("Incorrect thread state. Expected native thread state.");
+        abort();
+    }
+}
+
+// MODULE: main(cinterop)
+// FILE: main.kt
+@file:OptIn(kotlin.native.runtime.NativeRuntimeApi::class, kotlinx.cinterop.ExperimentalForeignApi::class)
+
+import kotlin.native.runtime.Debugging
+import kotlin.test.*
+import kotlinx.cinterop.staticCFunction
+import threadStates.*
+
+fun box(): String {
+    try {
+        runCallback(staticCFunction(::throwException))
+    } catch (e: CustomException) {
+        assertRunnableThreadState()
+        return "OK"
+    } catch (e: Throwable) {
+        assertRunnableThreadState()
+        fail("Wrong exception type: ${e.message}")
+    }
+    fail("No exception thrown")
+}
+
+fun assertRunnableThreadState() {
+    assertTrue(Debugging.isThreadStateRunnable)
+}
+
+class CustomException() : Exception()
+
+fun throwException() {
+    assertRunnableThreadState()
+    throw CustomException()
+}

compiler/testData/codegen/box/cinterop/threadStates/callbackWithFinally.kt

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+// TARGET_BACKEND: NATIVE
+// NATIVE_STANDALONE
+// FREE_COMPILER_ARGS: -opt-in=kotlin.native.internal.InternalForKotlinNative
+// MODULE: cinterop
+// FILE: threadStates.def
+language = C
+---
+void assertNativeThreadState();
+
+void runCallback(void(*callback)(void)) {
+    assertNativeThreadState();
+    callback();
+    assertNativeThreadState();
+}
+
+// FILE: threadStates.cpp
+#include <stdio.h>
+#include <stdlib.h>
+
+// Implemented in the runtime for test purposes.
+extern "C" bool Kotlin_Debugging_isThreadStateNative();
+
+extern "C" void assertNativeThreadState() {
+    if (!Kotlin_Debugging_isThreadStateNative()) {
+        printf("Incorrect thread state. Expected native thread state.");
+        abort();
+    }
+}
+
+// MODULE: main(cinterop)
+// FILE: main.kt
+@file:OptIn(kotlin.native.runtime.NativeRuntimeApi::class, kotlinx.cinterop.ExperimentalForeignApi::class)
+
+import kotlin.native.runtime.Debugging
+import kotlin.test.*
+import kotlinx.cinterop.staticCFunction
+import threadStates.*
+
+fun box(): String {
+    try {
+        runCallback(staticCFunction(::throwException))
+    } catch (e: CustomException) {
+        assertRunnableThreadState()
+        return "OK"
+    } finally {
+        assertRunnableThreadState()
+    }
+    fail("No exception thrown")
+}
+
+fun assertRunnableThreadState() {
+    assertTrue(Debugging.isThreadStateRunnable)
+}
+
+class CustomException() : Exception()
+
+fun throwException() {
+    assertRunnableThreadState()
+    throw CustomException()
+}

compiler/testData/codegen/box/cinterop/threadStates/callbackWithFinallyNoCatch.kt

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+// TARGET_BACKEND: NATIVE
+// NATIVE_STANDALONE
+// FREE_COMPILER_ARGS: -opt-in=kotlin.native.internal.InternalForKotlinNative
+// MODULE: cinterop
+// FILE: threadStates.def
+language = C
+---
+void assertNativeThreadState();
+
+void runCallback(void(*callback)(void)) {
+    assertNativeThreadState();
+    callback();
+    assertNativeThreadState();
+}
+
+// FILE: threadStates.cpp
+#include <stdio.h>
+#include <stdlib.h>
+
+// Implemented in the runtime for test purposes.
+extern "C" bool Kotlin_Debugging_isThreadStateNative();
+
+extern "C" void assertNativeThreadState() {
+    if (!Kotlin_Debugging_isThreadStateNative()) {
+        printf("Incorrect thread state. Expected native thread state.");
+        abort();
+    }
+}
+
+// MODULE: main(cinterop)
+// FILE: main.kt
+@file:OptIn(kotlin.native.runtime.NativeRuntimeApi::class, kotlinx.cinterop.ExperimentalForeignApi::class)
+
+import kotlin.native.runtime.Debugging
+import kotlin.test.*
+import kotlinx.cinterop.staticCFunction
+import threadStates.*
+
+fun box(): String {
+    try {
+        try {
+            runCallback(staticCFunction(::throwException))
+        } finally {
+            assertRunnableThreadState()
+        }
+        assertRunnableThreadState()
+    } catch (_: CustomException) {}
+    return "OK"
+}
+
+fun assertRunnableThreadState() {
+    assertTrue(Debugging.isThreadStateRunnable)
+}
+
+class CustomException() : Exception()
+
+fun throwException() {
+    assertRunnableThreadState()
+    throw CustomException()
+}

compiler/testData/codegen/box/cinterop/threadStates/directStaticCFunctionCall.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+// TARGET_BACKEND: NATIVE
+// NATIVE_STANDALONE
+// FREE_COMPILER_ARGS: -opt-in=kotlin.native.internal.InternalForKotlinNative
+@file:OptIn(kotlin.native.runtime.NativeRuntimeApi::class, kotlinx.cinterop.ExperimentalForeignApi::class)
+
+import kotlin.native.runtime.Debugging
+import kotlin.test.*
+import kotlinx.cinterop.*
+
+fun box(): String {
+    val funPtr = staticCFunction { ->
+        assertRunnableThreadState()
+    }
+    assertRunnableThreadState()
+    funPtr()
+    assertRunnableThreadState()
+    return "OK"
+}
+
+fun assertRunnableThreadState() {
+    assertTrue(Debugging.isThreadStateRunnable)
+}

compiler/testData/codegen/box/cinterop/threadStates/nativeCall.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+// TARGET_BACKEND: NATIVE
+// NATIVE_STANDALONE
+// FREE_COMPILER_ARGS: -opt-in=kotlin.native.internal.InternalForKotlinNative
+// MODULE: cinterop
+// FILE: threadStates.def
+language = C
+---
+#include <stdint.h>
+
+void assertNativeThreadState();
+
+int32_t answer() {
+    assertNativeThreadState();
+    return 42;
+}
+
+// FILE: threadStates.cpp
+#include <stdio.h>
+#include <stdlib.h>
+
+// Implemented in the runtime for test purposes.
+extern "C" bool Kotlin_Debugging_isThreadStateNative();
+
+extern "C" void assertNativeThreadState() {
+    if (!Kotlin_Debugging_isThreadStateNative()) {
+        printf("Incorrect thread state. Expected native thread state.");
+        abort();
+    }
+}
+
+// MODULE: main(cinterop)
+// FILE: main.kt
+@file:OptIn(kotlin.native.runtime.NativeRuntimeApi::class, kotlinx.cinterop.ExperimentalForeignApi::class)
+
+import kotlin.native.runtime.Debugging
+import kotlin.test.*
+import kotlinx.cinterop.*
+import threadStates.*
+
+fun box(): String {
+    answer()
+    assertRunnableThreadState()
+    return "OK"
+}
+
+fun assertRunnableThreadState() {
+    assertTrue(Debugging.isThreadStateRunnable)
+}

compiler/testData/codegen/box/cinterop/threadStates/nestedCallbackWithException.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+// TARGET_BACKEND: NATIVE
+// NATIVE_STANDALONE
+// FREE_COMPILER_ARGS: -opt-in=kotlin.native.internal.InternalForKotlinNative
+// MODULE: cinterop
+// FILE: threadStates.def
+language = C
+---
+void assertNativeThreadState();
+
+void runCallback(void(*callback)(void)) {
+    assertNativeThreadState();
+    callback();
+    assertNativeThreadState();
+}
+
+// FILE: threadStates.cpp
+#include <stdio.h>
+#include <stdlib.h>
+
+// Implemented in the runtime for test purposes.
+extern "C" bool Kotlin_Debugging_isThreadStateNative();
+
+extern "C" void assertNativeThreadState() {
+    if (!Kotlin_Debugging_isThreadStateNative()) {
+        printf("Incorrect thread state. Expected native thread state.");
+        abort();
+    }
+}
+
+// MODULE: main(cinterop)
+// FILE: main.kt
+@file:OptIn(kotlin.native.runtime.NativeRuntimeApi::class, kotlinx.cinterop.ExperimentalForeignApi::class)
+
+import kotlin.native.runtime.Debugging
+import kotlin.test.*
+import kotlinx.cinterop.staticCFunction
+import threadStates.*
+
+fun box(): String {
+    try {
+        runCallback(staticCFunction { ->
+            assertRunnableThreadState()
+            runCallback(staticCFunction(::throwException))
+        })
+    } catch (e: CustomException) {
+        assertRunnableThreadState()
+        return "OK"
+    } catch (e: Throwable) {
+        assertRunnableThreadState()
+        fail("Wrong exception type: ${e.message}")
+    }
+    fail("No exception thrown")
+}
+
+fun assertRunnableThreadState() {
+    assertTrue(Debugging.isThreadStateRunnable)
+}
+
+class CustomException() : Exception()
+
+fun throwException() {
+    assertRunnableThreadState()
+    throw CustomException()
+}

compiler/testData/codegen/box/cinterop/threadStates/nestedCallbackWithFinally.kt

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+// TARGET_BACKEND: NATIVE
+// NATIVE_STANDALONE
+// FREE_COMPILER_ARGS: -opt-in=kotlin.native.internal.InternalForKotlinNative
+// MODULE: cinterop
+// FILE: threadStates.def
+language = C
+---
+void assertNativeThreadState();
+
+void runCallback(void(*callback)(void)) {
+    assertNativeThreadState();
+    callback();
+    assertNativeThreadState();
+}
+
+// FILE: threadStates.cpp
+#include <stdio.h>
+#include <stdlib.h>
+
+// Implemented in the runtime for test purposes.
+extern "C" bool Kotlin_Debugging_isThreadStateNative();
+
+extern "C" void assertNativeThreadState() {
+    if (!Kotlin_Debugging_isThreadStateNative()) {
+        printf("Incorrect thread state. Expected native thread state.");
+        abort();
+    }
+}
+
+// MODULE: main(cinterop)
+// FILE: main.kt
+@file:OptIn(kotlin.native.runtime.NativeRuntimeApi::class, kotlinx.cinterop.ExperimentalForeignApi::class)
+
+import kotlin.native.runtime.Debugging
+import kotlin.test.*
+import kotlinx.cinterop.staticCFunction
+import threadStates.*
+
+fun box(): String {
+    try {
+        runCallback(staticCFunction { ->
+            assertRunnableThreadState()
+            runCallback(staticCFunction(::throwException))
+        })
+    } catch (e: CustomException) {
+        assertRunnableThreadState()
+        return "OK"
+    } finally {
+        assertRunnableThreadState()
+    }
+    fail("No exception thrown")
+}
+
+fun assertRunnableThreadState() {
+    assertTrue(Debugging.isThreadStateRunnable)
+}
+
+class CustomException() : Exception()
+
+fun throwException() {
+    assertRunnableThreadState()
+    throw CustomException()
+}

compiler/testData/codegen/box/cinterop/threadStates/nestedCalls.kt

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+// TARGET_BACKEND: NATIVE
+// NATIVE_STANDALONE
+// FREE_COMPILER_ARGS: -opt-in=kotlin.native.internal.InternalForKotlinNative
+// MODULE: cinterop
+// FILE: threadStates.def
+language = C
+---
+#include <stdint.h>
+
+void assertNativeThreadState();
+
+void runCallback(void(*callback)(void)) {
+    assertNativeThreadState();
+    callback();
+    assertNativeThreadState();
+}
+
+int32_t answer() {
+    assertNativeThreadState();
+    return 42;
+}
+
+// FILE: threadStates.cpp
+#include <stdio.h>
+#include <stdlib.h>
+
+// Implemented in the runtime for test purposes.
+extern "C" bool Kotlin_Debugging_isThreadStateNative();
+
+extern "C" void assertNativeThreadState() {
+    if (!Kotlin_Debugging_isThreadStateNative()) {
+        printf("Incorrect thread state. Expected native thread state.");
+        abort();
+    }
+}
+
+// MODULE: main(cinterop)
+// FILE: main.kt
+@file:OptIn(kotlin.native.runtime.NativeRuntimeApi::class, kotlinx.cinterop.ExperimentalForeignApi::class)
+
+import kotlin.native.runtime.Debugging
+import kotlin.test.*
+import kotlinx.cinterop.*
+import threadStates.*
+
+fun box(): String {
+    runCallback(staticCFunction { ->
+        assertRunnableThreadState()
+        answer()
+        Unit
+    })
+    assertRunnableThreadState()
+    return "OK"
+}
+
+fun assertRunnableThreadState() {
+    assertTrue(Debugging.isThreadStateRunnable)
+}

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/JvmAbiConsistencyTestBoxGenerated.java

@@ -6302,6 +6302,16 @@ public class JvmAbiConsistencyTestBoxGenerated extends AbstractJvmAbiConsistency
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/packages"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
             }
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/cinterop/threadStates")
+        @TestDataPath("$PROJECT_ROOT")
+        public class ThreadStates {
+            @Test
+            public void testAllFilesPresentInThreadStates() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/threadStates"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+            }
+        }
     }
 
     @Nested

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java

@@ -6068,6 +6068,16 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/packages"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
             }
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/cinterop/threadStates")
+        @TestDataPath("$PROJECT_ROOT")
+        public class ThreadStates {
+            @Test
+            public void testAllFilesPresentInThreadStates() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/threadStates"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
+            }
+        }
     }
 
     @Nested

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java

@@ -6302,6 +6302,16 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/packages"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
             }
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/cinterop/threadStates")
+        @TestDataPath("$PROJECT_ROOT")
+        public class ThreadStates {
+            @Test
+            public void testAllFilesPresentInThreadStates() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/threadStates"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+            }
+        }
     }
 
     @Nested

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java

@@ -6302,6 +6302,16 @@ public class IrBlackBoxCodegenWithIrInlinerTestGenerated extends AbstractIrBlack
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/packages"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
             }
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/cinterop/threadStates")
+        @TestDataPath("$PROJECT_ROOT")
+        public class ThreadStates {
+            @Test
+            public void testAllFilesPresentInThreadStates() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/threadStates"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+            }
+        }
     }
 
     @Nested

compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java

@@ -5522,6 +5522,19 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/packages"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
             }
         }
+
+        @TestMetadata("compiler/testData/codegen/box/cinterop/threadStates")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class ThreadStates extends AbstractLightAnalysisModeTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInThreadStates() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/cinterop/threadStates"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+            }
+        }
     }
 
     @TestMetadata("compiler/testData/codegen/box/classLiteral")