/**
     * Runs the given long running command. No more than 1 command may be running at any given time.
     *
     * @param command The command to run
     * @param commandDisplayName The command's display name, used for logging and error messages.
     *
     * @throws DaemonUnavailableException When this daemon is unable to run the command, either because it is currently executing another command
     * or is currently stopping.

	cr "github.com/minio/minio-go/v7/pkg/credentials"
)

var (
	// Minio endpoint (for STS API)
	stsEndpoint string

	// User account credentials
	minioUsername string
	minioPassword string

	// Display credentials flag
	displayCreds bool

	// Credential expiry duration
	expiryDuration time.Duration

	// Bucket to list
	bucketToList string

	// Session policy file (FIXME: add support in minio-go)

			check.pkgPathMap = make(map[string]map[string]bool)
			check.seenPkgMap = make(map[*Package]bool)
			check.markImports(check.pkg)
		}
		// If the same package name was used by multiple packages, display the full path.
		if len(check.pkgPathMap[pkg.name]) > 1 {
			return strconv.Quote(pkg.path)
		}
		return pkg.name
	}
	return ""
}

    /**
     * Returns true if it as a Gradle version that supports Kotlin scripts
     */
    boolean isSupportsKotlinScript();

    /**
     * Returns true if this version has a method for tests display names
     */
    boolean isHasTestDisplayNames();

    /**
     * Returns true if this version supports custom toolchain resolvers.
     */
    boolean isSupportsCustomToolchainResolvers();

    /**

		// Check if this proc was in a syscall before it stopped.
		// This means the syscall blocked. We need to emit it to the
		// viewer at this point because we only display the time the
		// syscall occupied a P when the viewer is in per-P mode.
		//
		// TODO(mknyszek): We could do better in a per-M mode because
		// all events have to happen on *some* thread, and in v2 traces

        def knownDefinition = KNOWN_DEFINITIONS[problem.definition.id.fqid]
        assert knownDefinition != null : "Unknown problem id: ${definition.id.fqid}"
        assert knownDefinition == definition.id.displayName : "Unexpected display name for problem: ${definition.id.fqid}. Expected=${knownDefinition}, actual=${definition.id.displayName}"

        def groupFqid = groupOf(definition.id.fqid)
        while (groupFqid != null) {

			Registry:            registry,
			MaxRequestsInFlight: 2,
		},
		authFn: authFn,

		metricsData: metricGroups,
	}
}

// metricDisplay - contains info on a metric for display purposes.
type metricDisplay struct {
	Name   string   `json:"name"`
	Help   string   `json:"help"`
	Type   string   `json:"type"`
	Labels []string `json:"labels"`
}

func (md metricDisplay) String() string {

[![official project](https://jb.gg/badges/official.svg)](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub)
[![TeamCity (simple build status)](https://img.shields.io/teamcity/http/teamcity.jetbrains.com/s/Kotlin_KotlinPublic_Compiler.svg)](https://teamcity.jetbrains.com/buildConfiguration/Kotlin_KotlinPublic_Compiler?branch=%3Cdefault%3E&buildTypeTab=overview&mode=builds)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.tasks.diagnostics;

import org.gradle.work.DisableCachingByDefault;

/**
 * Displays the dependency tree for a project. An instance of this type is used when you
 * execute the {@code dependencies} task from the command-line.
 */
@DisableCachingByDefault(because = "Not worth caching")

    }

    def "showsToolchains is properly visible as task"() {
        when:
        run("tasks")

        then:
        outputContains("javaToolchains - Displays the detected java toolchains.")
    }

    def "toolchains log contains progress info about installation suppliers"() {
        when:
        createDirs("a")
        settingsFile << """
                include 'a'