settingsFile << """
            include 'producer', 'consumer1', 'consumer2'
        """
        createDirs("consumer1", "consumer2")

        setupBuildWithColorTransform()
        buildFile << cacheableMakeGreenTransform(useInputChanges: false, sleep: 10)
        setupExternalDependency()

        buildFile << """
            project(":consumer1") {
                dependencies {

  auto consumer0_c = ops::Identity(scope.WithOpName("consumer0_c"), out0);
  auto consumer1 = ops::Identity(scope.WithOpName("consumer1"), out1);
  auto consumer2 = ops::Identity(scope.WithOpName("consumer2"), out2);
  auto consumer3 = ops::Identity(scope.WithOpName("consumer3"), out3);

  std::unique_ptr<Graph> graph(new Graph(OpRegistry::Global()));
  TF_CHECK_OK(scope.ToGraph(graph.get()));

        static UnpackedOutputConsumer composite(UnpackedOutputConsumer consumer1, UnpackedOutputConsumer consumer2) {
            return new UnpackedOutputConsumer() {
                @Override
                public void visitUnpackedOutputFileProperty(String propertyName, boolean optional, PropertyValue value, OutputFilePropertySpec spec) {
                    consumer1.visitUnpackedOutputFileProperty(propertyName, optional, value, spec);

    def "single transform used by multiple consumers creates a node per consumer"() {
        createDirs("producer", "consumer1", "consumer2")
        settingsFile << """
            include 'producer', 'consumer1', 'consumer2'
        """

        setupBuildWithColorTransformImplementation()
        setupExternalDependency()

        buildFile << """
            project(":consumer1") {
                dependencies {

                }
                task consumer2(type: SomeTask) {
                    prop = m.prop
                    outputFile = layout.buildDirectory.file("consumer2.txt")
                }
            }
        """

        when:
        run("slow", "consumer1", "consumer2", "--parallel", "--max-workers=3")

        then:

A _consumer_ needs to be understood in the large sense:

- a project that depends on another project is a _consumer_
- a _task_ that depends on an artifact is a finer grained consumer

In dependency management, a lot of the decisions we make depend on the type of project we are building, that is to say, <<#sub:being-respectful-consumers,what kind of _consumer_ we are>>.

[[sub:producer-variants]]

package com.acme.consumer;

import com.acme.lib.Person;

public class Consumer {
    private final Person person;

    public Consumer(Person person) {
        this.person = person;
    }

    public Person getPerson() {
        return person;
    }

 * <p>
 * A type can be marked {@link Consumer} or {@link Provider} but not both. A type is assumed to be
 * {@link Consumer} if it is not marked either {@link Consumer} or {@link Provider}.
 * <p>
 * A package can be marked {@link Consumer}. In this case, all types in the package are considered
 * to be a provider type regardless of whether they are marked {@link Consumer} or {@link Provider}.
 *
 * @see Provider
 * @since 4.0.0

The simple solution is also limited to cases where this artifact is not published to a repository.
This also implies that the consumer does not publish a dependency to this artifact.

.Producer's build
====
include::sample[dir="kotlin",files="producer/build.gradle.kts[]"]
include::sample[dir="groovy",files="producer/build.gradle[]"]
====

.Consumer's build
====
include::sample[dir="kotlin",files="consumer/build.gradle.kts[]"]
include::sample[dir="groovy",files="consumer/build.gradle[]"]
====

See also:

- <<../userguide/cross_project_publications.adoc#cross_project_publications, Sharing outputs between projects>>