[!fuzz] skip
[short] skip
env GOCACHE=$WORK/cache

# There are no seed values, so 'go test' should finish quickly.
go test

# For the fuzzing phase, we reduce GOMAXPROCS to avoid consuming too many
# resources during the test. Ideally this would just free up resources to run
# other parallel tests more quickly, but unfortunately it is actually necessary
# in some 32-bit environments to prevent the fuzzing engine from running out of

 * of the published library.
 * The following disambiguation rule encodes this assumption for the case where a java library is published
 * with variants using Gradle module metadata. This will allow us to migrate to consuming the new module
 * metadata format by default without breaking a bunch of consumers that depend on this assumption,
 * declaring no preference for a particular variant.
 */
@ServiceScope(Scope.Global.class)

     */
    List<String> getDeclarationAlternatives();

    /**
     * Return the names of configurations that should be used to consume a component instead of consuming this configuration.
     *
     * <p>This property is only relevant if this configuration deprecated for resolution.</p>
     */
    List<String> getResolutionAlternatives();

    /**

 *     }
 *   }
 *
 *   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;
        }