when:
        setToNull(property)

        then:
        assertHasProducer(property, task)
    }

    def "producer task of upstream provider is ignored when producer task attached to property"() {
        def task = Mock(Task)
        def upstream = Mock(Task)
        def property = propertyWithNoValue()
        property.set(supplierWithProducer(upstream))

        expect:

            LOGGER.warn("artifact '{}' already attached, replacing previous instance", artifact);
            attachedArtifacts.set(index, artifact);
        } else {
            attachedArtifacts.add(artifact);
        }
    }

    /**
     * Returns a read-only list of the attached artifacts to this project.
     *
     * @return the attached artifacts of this project
     */

    }

    // Documents existing behaviour. The absolute path of the input artifact is baked into the workspace identity
    // for incremental transforms, and so when the path changes the outputs are invalidated
    def "can attach #description to input artifact property with incrementally transformed artifact but it has no effect when not caching"() {
        createDirs("a", "b", "c")
        settingsFile << "include 'a', 'b', 'c'"

            }
            noMoreDependencies()
        }
    }

    @Issue("gradle/gradle#5450")
    def "doesn't fail with NPE if no component is attached to a publication"() {
        createBuildScripts("""
        publishing {
            publications {
                java(IvyPublication) {
                    artifact jar
                }

            }
        }

        expect:
        registry.realize("b", Bean).value == "b-mutate a-defaults"
        registry.realize("a", Bean).value == "a-mutate"
    }

    def "can attach a mutator with inputs to all elements linked from an element"() {
        given:
        registry.register("parent") { it.unmanagedNode Integer, { MutableModelNode node ->

        this.netbiosName = netbiosName;
    }


    /**
     * @return the context this session is attached to
     */
    @Override
    public CIFSContext getContext () {
        return this.transport.getContext();
    }


    /**
     * @return the transport this session is attached to
     */
    @Override
    public SmbTransportImpl getTransport () {

        return loggingServices;
    }

    @Override
    public GradleExecuter withTestConsoleAttached() {
        return withTestConsoleAttached(ConsoleAttachment.ATTACHED);
    }

    @Override
    public GradleExecuter withTestConsoleAttached(ConsoleAttachment consoleAttachment) {
        this.consoleAttachment = consoleAttachment;

		})
		if err != nil {
			c.Fatalf("export %d: Unable to attach policy: %v", caseNum, err)
		}
	}

	for groupDN, policies := range content.ldapGroupPolicyMappings {
		_, err := s.adm.AttachPolicyLDAP(ctx, madmin.PolicyAssociationReq{
			Policies: policies,
			Group:    groupDN,
		})
		if err != nil {
			c.Fatalf("export %d: Unable to attach group policy: %v", caseNum, err)
		}
	}

	xdsNamespace                       = "namespace"
	xdsSelector                        = "selector"
)

// app a has one pod
// the waypoint has two pods with different service accounts
// the waypoint is namespace attached
func setupPolicyTest(t *testing.T, s *ambientTestServer) {
	s.addPods(t, "127.0.0.1", "pod1", "sa1", map[string]string{"app": "a"}, nil, true, corev1.PodRunning)
	s.assertEvent(t, s.podXdsName("pod1"))

        setStartDate:...