bindings.getRulesWithSubject(nodeAtState("a", ModelNode.State.Mutated)) as List == [rule1]
        bindings.getRulesWithSubject(nodeAtState("a.1", ModelNode.State.Mutated)) as List == [rule3]
        bindings.getRulesWithSubject(nodeAtState("a.2", ModelNode.State.Mutated)) as List == [rule2]
        bindings.getRulesWithSubject(nodeAtState("b", ModelNode.State.Mutated)).empty
    }

    def "binds multiple by-path rules to subject"() {

type Manager interface {
	// Update is used when the object has already been merged (non-apply
	// use-case), and simply updates the managed fields in the output
	// object.
	//  * `liveObj` is not mutated by this function
	//  * `newObj` may be mutated by this function
	// Returns the new object with managedFields removed, and the object's new
	// proposed managedFields separately.

	tcs := []struct {
		config   string
		webhook  string
		mutated  bool
		expected string
	}{
		{
			config:   "test-config",
			webhook:  "test-webhook",
			mutated:  true,
			expected: `{"configuration":"test-config","webhook":"test-webhook","mutated":true}`,
		},
		{
			config:   "test-config",
			webhook:  "test-webhook",
			mutated:  false,

            setProperty("projectMutatedBuildProperty", "mutated")
            require(projectMutatedBuildProperty == "mutated")

            val projectMutatedUserHomeProperty: String by project
            require(projectMutatedUserHomeProperty == "user home value")

            setProperty("projectMutatedUserHomeProperty", "mutated")
            require(projectMutatedUserHomeProperty == "mutated")
        }
        """.trimIndent()

     *
     * @param path the project path
     *
     * @return a mutable dependency, added to this container
     */
    ProjectDependencySpecBuilder project(String path);

    /**
     * Defines a new dependency, based on a library name. The returned dependency can be mutated.
     *
     * @param name of the library
     *

        expect:
        def reference = ModelReference.of("some.path", String).atState(ModelNode.State.Mutated)
        reference.scope == null
        reference.path == ModelPath.path("some.path")
        reference.type == ModelType.of(String)
        !reference.untyped
        reference.state == ModelNode.State.Mutated

        def original = ModelReference.of(String)
        original.atState(original.state).is(original)
    }

            mutated = true;
        }

        @Override
        public void setStatusScheme(List<String> scheme) {
            this.statusScheme = scheme;
            mutated = true;
        }

        @Override
        public void attributes(Action<? super AttributeContainer> attributesConfiguration) {
            mutated = true;

     *
     * This method will emit a detailed deprecation method with suggestions if the usage is inconsistent.  It will then attempt to mutate
     * the usage to match the expectation.  If the usage cannot be mutated, it will throw an exception.
     *
     * Does <strong>NOT</strong> check anything to do with deprecated usage.
     *

	}
}

// MutationAuditAnnotation logs if a webhook invocation mutated the request object
type MutationAuditAnnotation struct {
	Configuration string `json:"configuration"`
	Webhook       string `json:"webhook"`
	Mutated       bool   `json:"mutated"`
}

// PatchAuditAnnotation logs a patch from a mutating webhook
type PatchAuditAnnotation struct {

import org.gradle.internal.service.scopes.Scope
import org.gradle.internal.service.scopes.ServiceScope
import java.util.concurrent.ConcurrentHashMap


/**
 * The environment state that was mutated at the configuration phase and has to be restored before running a build from the cache.
 *
 * The class can operate in two modes. First is the tracking mode when all environment-modifying operations are stored