}

    def "transform can receive a file collection containing substituted external dependencies as parameter"() {
        createDirs("tools", "tools/tool-a", "tools/tool-b")
        file("tools/settings.gradle") << """
            include 'tool-a', 'tool-b'
        """
        file("tools/build.gradle") << """
            allprojects {
                group = 'test'
                configurations.create("default")

    private final Map<ToolType, CommandLineToolConfigurationInternal> tools = new HashMap<ToolType, CommandLineToolConfigurationInternal>();

    public DefaultSwiftcPlatformToolChain(NativePlatform platform) {
        this.platform = platform;
    }

    public void add(DefaultCommandLineToolConfiguration tool) {
        tools.put(tool.getToolType(), tool);
    }

    @Override

        return tools.get(toolType);
    }

    public Collection<GccCommandLineToolConfigurationInternal> getTools() {
        return tools.values();
    }

    public Collection<GccCommandLineToolConfigurationInternal> getCompilers() {
        return Arrays.asList(tools.get(ToolType.C_COMPILER), tools.get(ToolType.CPP_COMPILER), tools.get(ToolType.OBJECTIVEC_COMPILER), tools.get(ToolType.OBJECTIVECPP_COMPILER));
    }

        get() = analysisSession.token

    override fun getResolveExtensionScopeWithTopLevelDeclarations(): KaScope {
        val tools = analysisSession.extensionTools
        if (tools.isEmpty()) return KaEmptyScope(token)
        return KaFirResolveExtensionScope(analysisSession, tools)
    }

    @OptIn(KtModuleStructureInternals::class)
    override fun isResolveExtensionFile(file: VirtualFile): Boolean =

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.api;

import javax.tools.DocumentationTool;
import javax.tools.JavaFileManager;
import javax.tools.StandardLocation;

import java.io.File;
import java.nio.file.Path;
import java.util.Objects;
import java.util.Optional;
import java.util.StringJoiner;

import org.gradle.nativeplatform.toolchain.internal.metadata.CompilerMetaDataProvider
import org.gradle.nativeplatform.toolchain.internal.tools.CommandLineToolSearchResult
import org.gradle.nativeplatform.toolchain.internal.tools.GccCommandLineToolConfigurationInternal
import org.gradle.nativeplatform.toolchain.internal.tools.ToolSearchPath
import org.gradle.platform.base.internal.toolchain.ComponentFound

import java.util.List;

/**
 * The <a href="https://swift.org/">Swift Compiler</a> tool chain.
 *
 * @since 4.1
 */
@Incubating
public interface Swiftc extends NativeToolChain {
    /**
     * The paths setting required for executing the tool chain.
     * These are used to locate tools for this tool chain, and are prepended to the system PATH when executing these tools.
     */
    List<File> getPath();

    /**

                linker.executable = 'does-not-exist'
            }
        }
    }
}
"""

        then:
        succeeds "help"
    }

    @ToBeFixedForConfigurationCache
    def "tool chain is not available when no tools are available"() {
        when:
        buildFile << """
model {
    toolChains {
        ${toolChain.id} {
            eachPlatform {
                assembler.executable = 'does-not-exist'

1. Run the tool with:

```
go run docs/auditlog/auditlog-echo.go
```

The listen port has a default value (8080), but can be set with the `-port` flag.

2. Configure audit logging in MinIO with for example:

```
mc admin config set myminio audit_webhook enable=on endpoint=http://localhost:8080
```

    /**
     * The paths setting required for executing the tool chain.
     * These are used to locate tools for this tool chain, and are prepended to the system PATH when executing these tools.
     */
    List<File> getPath();

    /**
     * Append an entry or entries to the tool chain path.
     *