then:
        notThrown(NullPointerException)
        status.pid == null
    }

    def "PID unboxing should not happen in DaemonStopEvent"() {
        given:
        Long unknownPID = null;

        when:
        def daemonStopEvent = new DaemonStopEvent(null, unknownPID, null, null);

        then:
        notThrown(NullPointerException)
        daemonStopEvent.pid == null
    }

        e.message == "Failed to cast object $arg of type ${arg.class.name} to target type ${Integer.name}"

        when:
        def result = cast(CharSequence, arg)

        then:
        notThrown(ClassCastException)
        result.is arg
    }

        given:
        unlockUncleanly()

        when:
        createLock(Exclusive).writeFile {}

        then:
        notThrown FileIntegrityViolationException
    }

    def "can lock a file"() {
        when:
        def lock = createLock(lockMode)

        then:

        withConnection { ProjectConnection connection ->
            connection.action(action).run()
        }

        then:
        notThrown Exception

        cleanup:
        classloader?.close()
    }

}
'''

        buildFile << 'task doStuff'

        when:
        executer.usingInitScript(initScript1).usingInitScript(initScript2).withTasks('doStuff').run()

        then:
        notThrown(Throwable)
    }

    def "each Kotlin init script has independent ClassLoader"() {
        given:
        createExternalJar()

        and:
        TestFile initScript1 = file('init1.init.gradle.kts')

            newBuild().forLaunchables(task).run()
            newBuild().forLaunchables(selector).run()
        }

        then:
        notThrown(Throwable)
    }

        when:
        withConnection { connection ->
            fetchCustomModelsWithRestrictedMemoryAction(connection)
        }

        then:
        notThrown(GradleConnectionException)
        assertHasConfigureSuccessfulLogging()
    }

    private fetchCustomModelsWithRestrictedMemoryAction(ProjectConnection connection) {

        connection.disconnect()
        daemonConnection.stop()

        then:
        notThrown()
    }

    def "handles case where cannot receive from connection"() {
        when:
        connection.queueBroken()
        daemonConnection.stop()

        then:
        notThrown()
    }

    def "handles failure to notify stdin handler"() {
        StdinHandler handler = Mock()

    }

    def "open does nothing when directory already exists"() {
        given:
        cacheDir.createDir()

        when:
        store.open()

        then:
        notThrown(RuntimeException)
    }

    def "open locks cache directory with requested mode"() {

    }

    def "disconnect before build starts"() {
        when:
        def connector = toolingApi.connector()
        connector.connect()
        connector.disconnect()

        then:
        notThrown(Exception)
        assertNoRunningDaemons()
    }

    def "can call disconnect after the build was cancelled"() {
        buildFile.text = """
            task hang {
                doLast {