}

    override fun externalProcessStarted(command: String, consumer: String) {
        if (Workarounds.canStartExternalProcesses(consumer)) {
            return
        }
        externalProcessListener.onExternalProcessStarted(command, consumer)
    }

    override fun fileOpened(file: File, consumer: String) {
        if (Workarounds.canReadFiles(consumer)) {
            return

        } else {
            locationForCaller(consumer, diagnostics.source)
        }
    }

    private
    fun locationForCaller(consumer: String?, source: UserCodeSource?): PropertyTrace {
        return if (source != null) {
            PropertyTrace.BuildLogic(source.displayName, null)
        } else if (consumer != null) {
            PropertyTrace.BuildLogicClass(consumer)
        } else {

     */
    fun systemPropertyRead(key: String, value: Any?, consumer: String?)

    fun envVariableRead(key: String, value: String?, consumer: String?)

    fun fileOpened(file: File, consumer: String?)

    fun fileObserved(file: File, consumer: String?)

    fun fileSystemEntryObserved(file: File, consumer: String?)

    fun directoryChildrenObserved(directory: File, consumer: String?)

) : ExecutionAccessChecker {
    override fun disallowedAtExecutionInjectedServiceAccessed(injectedServiceType: Class<*>, getterName: String, consumer: String) {
        if (shouldReportExecutionTimeAccess()) {
            broadcaster.disallowedAtExecutionInjectedServiceAccessed(injectedServiceType, getterName, consumer)
        }
    }

    private
    fun shouldReportExecutionTimeAccess(): Boolean =

@EventScope(Scope.BuildTree::class)
interface ProblemFactory {
    /**
     * Returns a default location inferred from the calling thread's state.
     */
    fun locationForCaller(consumer: String? = null): PropertyTrace

    /**
     * Creates a problem with the given message and exception.
     *
     * Problem has no documentation, and a default location is inferred from the calling thread's state.

import com.microsoft.playwright.Playwright
import org.gradle.test.fixtures.Flaky
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.UnitTestPreconditions

import java.util.function.Consumer

import static org.gradle.integtests.fixtures.configurationcache.ConfigurationCacheProblemsFixture.resolveConfigurationCacheReport

// Ignore test on non-Windows platforms on CI since Playwright has unfulfilled package

) : InstrumentedExecutionAccess.Listener {

    override fun disallowedAtExecutionInjectedServiceAccessed(injectedServiceType: Class<*>, propertyName: String, consumer: String) {
        executionAccessChecker.disallowedAtExecutionInjectedServiceAccessed(injectedServiceType, propertyName, consumer)
    }

) : ConfigurationCacheProblemsListener {

    override fun disallowedAtExecutionInjectedServiceAccessed(injectedServiceType: Class<*>, getterName: String, consumer: String) {
        val problem = problemFactory.problem(consumer) {
            text("accessing non-serializable type ")
            reference(injectedServiceType)
            text(" caused by invocation ")
            reference(getterName)
        }

    private
    val mode = ModeHolder()

    override fun systemPropertyChanged(key: Any, value: Any?, consumer: String?) =
        mode.toTrackingMode().systemPropertyChanged(key, value, consumer)

    override fun systemPropertyLoaded(key: Any, value: Any?, oldValue: Any?) {
        mode.toTrackingMode().systemPropertyLoaded(key, value, oldValue)
    }

                outputFile.set(layout.buildDirectory.file("consumer-output.txt"))
            }
        '''

        and:
        file('producer-input.txt').text = '42'

        when:
        configurationCacheRun 'consumer'

        then:
        configurationCache.assertStateStored(true)

        and:
        file('build/consumer-output.txt').text == '42'
    }