type fileTransport struct {
	fh fileHandler
}

// NewFileTransport returns a new [RoundTripper], serving the provided
// [FileSystem]. The returned RoundTripper ignores the URL host in its
// incoming requests, as well as most other properties of the
// request.
//
// The typical use case for NewFileTransport is to register the "file"
// protocol with a [Transport], as in:
//
//	t := &http.Transport{}

            }
            task query {
                doLast {
                    assert configurations.compileClasspath.files
                    def id = configurations.compileClasspath.incoming.resolutionResult
                        .allDependencies.first().selected.id
                    dependencies.createArtifactResolutionQuery()
                        .forComponents(id)

        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.DOCUMENTATION))
        attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named("incubation-report-$reportType"))
    }
    extendsFrom(reports)

information about the test infrastructure, see [performance](../performance) and [internal-performance-testing](../internal-performance-testing)

Note that when running these tests locally, they will use the version of the build scan plugin in `../incoming/plugin.json`.  On CI, this file is populated as an artifact dependency from an upstream build.  To run locally, you will need to set this value whatever version of the build scan plugin you want to test with (whatever value is in source control is...

    if (extraDependencies) {
      return extraDependencies(op, /*incoming=*/true);
    } else {
      return empty_op_set;
    }
  };
  auto ctrlSuccessors =
      [&](Operation* op) -> llvm::SmallVector<mlir::Operation*, 4> const& {
    if (extraDependencies) {
      return extraDependencies(op, /*incoming=*/false);
    } else {
      return empty_op_set;
    }
  };

  int i = 0;

    scm 'commons-codec:commons-codec:1.7'
    scm 'some:unresolved:2.5'
}

// tag::walk-task[]
tasks.register('walkDependencyGraph', DependencyGraphWalk) {
    dependencies = configurations.scm.incoming
}

abstract class DependencyGraphWalk extends DefaultTask {

    @Input
    abstract Property<ResolvableDependencies> getDependencies()

    @TaskAction
    void walk() {

 * limitations under the License.
 */

package org.gradle.test.fixtures.server.http;

/**
 * Some action that must be met before it is legal to wait for an incoming request.
 */
interface WaitPrecondition {
    /**
     * Must be called under lock.
     */
    void assertCanWait() throws IllegalStateException;

	}

	// Invokes the execve system call.
	// Re-uses the same pid. This preserves the pid over multiple server-respawns.
	return syscall.Exec(argv0, os.Args, os.Environ())
}

// freezeServices will freeze all incoming S3 API calls.
// For each call, unfreezeServices must be called once.
func freezeServices() {
	// Use atomics for globalServiceFreeze, so we can read without locking.

                configurations.forEach { c ->
                    if (c.isCanBeResolved) {
                        println("Downloading dependencies for '$path' - ${c.name}")
                        val result = c.incoming.artifactView { lenient(true) }.artifacts
                        result.failures.forEach {
                            println("- Ignoring Error: ${it.message}")
                        }
                    }

        file("consumer/build.gradle") << """
dependencies {
    implementation 'com.example:test:1.0'
}

task resolve {
    def artifacts = configurations.runtimeClasspath.incoming.artifactView {
        withVariantReselection()
        attributes {
            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_RUNTIME))