*/
public abstract class InterceptScope {

    private enum CallType {
        METHOD("call method"),
        GET_PROPERTY("get property"),
        SET_PROPERTY("set property"),
        CONSTRUCTOR("call constructor");

        final String descriptorStringPrefix;

        CallType(String descriptorStringPrefix) {

    fun WriteContext.encodeLoop(coroutineContext: CoroutineContext) {
        do {
            val call = encodeCall!!
            suspend {
                codec.run {
                    encode(call.value)
                }
            }.startCoroutine(
                Continuation(coroutineContext) {
                    when (val k = call.k) {
                        null -> {
                            encodeCall = null

 * by subclasses as they define our entry point behaviour, but they are protected to enable
 * testing as it's difficult to test something that will call System.exit().
 */
public abstract class EntryPoint {
    private final PrintStream originalStdErr = System.err;

    /**
     * Unless the createCompleter() method is overridden, the JVM will exit before returning from this method.
     */

If more than one init script is found, they will all be executed in the order specified above.

Scripts in a given directory are executed in alphabetical order.

        "--add-opens=java.base/java.lang=ALL-UNNAMED",
        "--add-opens=java.base/java.lang.invoke=ALL-UNNAMED",
        "--add-opens=java.base/java.util=ALL-UNNAMED",
        "--add-opens=java.prefs/java.util.prefs=ALL-UNNAMED", // required by PreferenceCleaningGroovySystemLoader
        "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED", // Required by JdkTools and JdkJavaCompiler

    @Test
    fun `sets progress display name on store`() {
        // given:
        val buildOperationRunner = mock<BuildOperationRunner> {
            on { call<Unit>(any()) } doReturn Unit
        }
        val stateFile = testDirectoryProvider.file("stateFile")

        // when:
        buildOperationRunner.withStoreOperation("key") {
            StoreResult(stateFile, null)

        def encoder = new OutputStreamBackedEncoder(outputStream)
        closure.call(encoder)
    }

    @Override
    void decodeFrom(InputStream inputStream, Closure<Decoder> closure) {
        def decoder = new InputStreamBackedDecoder(inputStream)
        closure.call(decoder)
    }

        state.disableForCurrentThread() // <1>
        state.disableForCurrentThread() // <2>

        state.restoreForCurrentThread() // Revert call at <2>, restore to "disabled" state set by call at <1>
        assertFalse(state.isEnabledForCurrentThread())

        state.restoreForCurrentThread() // Revert call at <1>, restore to "enabled" state
        assertTrue(state.isEnabledForCurrentThread())
    }

    @Test

        )

        assertEquals(2, result.size)
        assertEquals(listOf(2, 4), result.map { it.location.sourceData.lineRange.first })
        assertTrue(result.all { it.reason == DocumentCheckFailureReason.DuplicatePluginsBlock })
    }

    @Test
    fun `reports all duplicate pluginManagement blocks`() {
        val result = pluginManagementSchema.runChecks(
            """
            pluginManagement { }

                "--add-opens", "jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
                "--add-opens", "jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED",
                "--add-opens", "jdk.compiler/com.sun.tools.javac.jvm=ALL-UNNAMED",
                "--add-opens", "jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED",