)

    private
    fun isBuildSrcBuild(invocationSource: Any): Boolean =
        (invocationSource as? GradleInternal)?.run {
            !isRootBuild && identityPath.name == BUILD_SRC
        } ?: false

    private
    fun atConfigurationTime() = configurationTimeBarrier.isAtConfigurationTime

    private
    fun isInputTrackingDisabled() = !inputTrackingState.isEnabledForCurrentThread()

        override fun <T> service(type: Class<T>): T = delegate.service(type)
    }

    class OwnerFlowScope(override val delegate: Gradle) : IsolateOwners() {
        override fun <T> service(type: Class<T>): T = (delegate as GradleInternal).services.get(type)
    }

    class OwnerFlowAction(override val delegate: OwnerFlowScope) : IsolateOwners() {

     */
    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?)

) {
    private
    val methodCache = hashMapOf<Class<*>, Method?>()

    fun forObject(value: Any) =
        forClass(value.javaClass)

    fun forClass(type: Class<*>) = methodCache.computeIfAbsent(type) {
        it.firstAccessibleMatchingMethodOrNull(predicate)
    }
}


internal
fun Class<*>.firstAccessibleMatchingMethodOrNull(predicate: Method.() -> Boolean): Method? =

    /**
     * Determines whether the cache entry can be loaded or needs to be stored or updated.
     */
    fun initializeCacheEntry()

    /**
     * Loads the scheduled tasks from cache, if available, or else runs the given function to schedule the tasks and then
     * writes the result to the cache.
     */

    private
    val afterProject = mutableListOf<IsolatedProjectAction>()

    override fun beforeProject(action: IsolatedProjectAction) {
        // TODO:isolated encode Application instances as part of the Environment to avoid waste
        beforeProject.add(withUserCodeApplicationContext(action))
    }

    override fun afterProject(action: IsolatedProjectAction) {
        afterProject.add(withUserCodeApplicationContext(action))

    private
    fun createFromPaths(paths: List<String>, isCaseSensitive: Boolean = true): DefaultIgnoredConfigurationInputs {
        return DefaultIgnoredConfigurationInputs(paths.joinToString(";"), isCaseSensitive, rootDir)
    }

    @Test
    fun `if created with an empty or null paths list, does not recognize an empty string`() {

import java.lang.IllegalStateException
import java.util.concurrent.Executors


class InputTrackingStateTest {

    @Test
    fun `input tracking is enabled by default`() {
        val state = InputTrackingState()

        assertTrue(state.isEnabledForCurrentThread())
    }

    @Test
    fun `input tracking can be disabled`() {
        val state = InputTrackingState()
        state.disableForCurrentThread()

    protected
    fun serializationProblemsOf(bean: Any, codec: Codec<Any?> = userTypesCodec()): List<PropertyProblem> =
        mutableListOf<PropertyProblem>().also { problems ->
            writeTo(
                NullOutputStream.INSTANCE,
                bean,
                codec,
                object : AbstractProblemsListener() {
                    override fun onProblem(problem: PropertyProblem) {

    }

    override fun systemPropertyRemoved(key: Any, consumer: String) {
        environmentChangeTracker.systemPropertyRemoved(key)
    }

    override fun systemPropertiesCleared(consumer: String) {
        environmentChangeTracker.systemPropertiesCleared()
    }

    override fun envVariableQueried(key: String, value: String?, consumer: String) {