*     }
 *   }
 *
 *   public void onFailure(Call call, IOException e) {
 *   ... // Handle the failure.
 *   }
 * });
 * ```
 *
 * These examples will not work if you're consuming the response body on another thread. In such
 * cases the consuming thread must call [close] when it has finished reading the response
 * body.
 *
 * ### The response body can be consumed only once.
 *

 * limitations under the License.
 */

package org.gradle.operations.execution;

import java.io.File;
import java.util.Set;

/**
 * The consuming visitor for file properties on work.
 * <p>
 * Properties are visited depth-first lexicographical.
 * Roots are visited in semantic order (i.e. the order in which they make up the file collection)

The standalone plugin project and the consuming project can be combined into a single unit, making it straightforward to try out or debug changes without re-publishing the binary file:

----
.
├── include-plugin-build   // <1>
│   ├── build.gradle
│   └── settings.gradle
└── url-verifier-plugin    // <2>
    ├── build.gradle
    ├── settings.gradle
    └── src
----
<1> Consuming project that includes the plugin project

	}
}

func TestBoringFinalizers(t *testing.T) {
	if runtime.GOOS == "nacl" || runtime.GOOS == "js" {
		// Times out on nacl and js/wasm (without BoringCrypto)
		// but not clear why - probably consuming rand.Reader too quickly
		// and being throttled. Also doesn't really matter.
		t.Skipf("skipping on %s/%s", runtime.GOOS, runtime.GOARCH)
	}

	k, err := GenerateKey(rand.Reader, 2048)
	if err != nil {

        when:
        run 'project1:resolveDependencies', 'project2:resolveDependencies'

        then:
        noExceptionThrown()
    }

    def "long running task in producing project does not block task in consuming project"() {
        blockingServer.start()

        createDirs("producer", "consumer")
        settingsFile << """
            include "producer"
            include "consumer"
        """

    }

    /**
     * @param platformId The consuming platform.
     */
    public VariantGraphResolveState getDefaultVariant(NodeState from, @Nullable ComponentIdentifier platformId) {

        if (isProjectArtifact()) {
            // Use a node to eagerly calculate the file if this artifact will be used as a dependency of some other node
            // This is to avoid having to lock the producing project when a consuming task in another project runs
            this.resolvedArtifactDependency = new ResolveAction(this);
        } else {
            this.resolvedArtifactDependency = null;
        }

This is where a *build cache* is helpful.

The build cache stores previous build results and restores them when needed.
It prevents the redundant work and cost of executing time-consuming and expensive processes.

When the build cache has been used to repopulate the local directory, the tasks are marked as `FROM-CACHE`:

[source,text]
----
$ ./gradlew compileJava --build-cache

        installation("build/install/main").exec().out == "CPP_C"
    }

    @Issue("GRADLE-2925")
    @ToBeFixedForConfigurationCache
    def "headers for source set added to library binary are available to consuming binary"() {
        def app = new CppHelloWorldApp()
        given:
        buildFile << """
apply plugin: "cpp"

model {
    components {
        main(NativeExecutableSpec) {
            sources {

     * <li>{@link SortOrder#CONSUMER_FIRST} : Artifacts for a consuming component should appear before artifacts for its dependencies.</li>
     * <li>{@link SortOrder#DEPENDENCY_FIRST} : Artifacts for a consuming component should appear after artifacts for its dependencies.</li>
     * </ul>