given:
        Task producer1 = task("producer1", type: AsyncWithOutputDirectory)
        _ * producer1.outputDirectory >> file("dir1")
        Task producer2 = task("producer2", type: AsyncWithOutputDirectory)
        _ * producer2.outputDirectory >> file("dir2")
        Task destroyer = task("destroyer", type: AsyncWithDestroysFile)

                api1 files(producer1)
                api2 files(producer2)
            }
        """)

        when:
        run "resolveapi1", "resolveapi2"
        then:
        executedAndNotSkipped(":resolveapi1", ":resolveapi2")
        outputContains("artifacts: [producer1.jar (producer1.jar)]")
        outputContains("artifacts: [producer2.jar (producer2.jar)]")
    }

[[sub:producer-variants]]
== Producer variants

A producer may want to generate different artifacts for different kinds of consumers: for the same source code, different _binaries_ are produced.
Or, a project may produce artifacts which are for consumption by other projects (same repository) but not for external use.

A typical example in the Java world is the Guava library which is published in different versions: one for Java projects, and one for Android projects.

          "url": "producer-1.0.jar",
          "size": 261,
          "sha1": "29acdaf26447e93ce0c8af7357e6fd4e2d1db71d",
          "md5": "6c53fdd588deb0abfc636c382e25d92e"
        }
      ]
    },
    {
      "name": "mongodbSupportApi",
      "attributes": {
        "org.gradle.usage": "java-api"
      },
      "files": [
        {
          "name": "producer-1.0.jar",

            start {
                result1 = cache.get("key", producer, Stub(Runnable))
            }
            start {
                result2 = cache.get("key", producer, Stub(Runnable))
            }
            start {
                result3 = cache.get("key", producer, Stub(Runnable))
            }
            start {
                result4 = cache.get("key", producer, Stub(Runnable))
            }
        }

            result.assertTaskOrder(cleanBar.fullPath, generateBar.fullPath, generate.fullPath)
        }
    }

    def "a destroyer task finalizing both a destroyer and a producer task will run after producer tasks"() {
        def foo = subproject(':foo')
        def bar = subproject(':bar')

        def cleanBar = bar.task('cleanBar').destroys('build/bar')

  <!-- that they should prefer consuming it instead. -->
  <!-- do-not-remove: published-with-gradle-metadata -->
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.gradle.demo</groupId>
  <artifactId>producer</artifactId>
  <version>1.0</version>
  <dependencies>
    <dependency>
      <groupId>org.mongodb</groupId>
      <artifactId>mongodb-driver-sync</artifactId>
      <version>3.9.1</version>

.Settings
====
include::sample[dir="kotlin",files="settings.gradle.kts[]"]
include::sample[dir="groovy",files="settings.gradle[]"]
====

.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[]"]

        schema.attribute(attr2)
        producer.attribute(attr2)
        producer.attribute(attr3)

        expect:
        schema.withProducer(producer).selectionSchema.hasAttribute(attr1)
        schema.withProducer(producer).selectionSchema.hasAttribute(attr2)
        schema.withProducer(producer).selectionSchema.hasAttribute(attr3)
    }

                        + "This can lead to incorrect results being produced, depending on what order the tasks are executed",
                    consumer,
                    producer
                ))
                .solution("Declare task '" + producer + "' as an input of '" + consumer + "'")
                .solution("Declare an explicit dependency on '" + producer + "' from '" + consumer + "' using Task#dependsOn")