*/

package org.gradle.nativeplatform.toolchain.internal;

import org.gradle.util.internal.GUtil;

// Should use stronger modelling for this and make the set of tools open, rather than hard-coding here
public enum ToolType {
    CPP_COMPILER("C++ compiler"),
    C_COMPILER("C compiler"),
    OBJECTIVECPP_COMPILER("Objective-C++ compiler"),
    OBJECTIVEC_COMPILER("Objective-C compiler"),

        tools.put(ToolType.CPP_COMPILER, instantiator.newInstance(DefaultCommandLineToolConfiguration.class, ToolType.CPP_COMPILER));
        tools.put(ToolType.LINKER, instantiator.newInstance(DefaultCommandLineToolConfiguration.class, ToolType.LINKER));
        tools.put(ToolType.STATIC_LIB_ARCHIVER, instantiator.newInstance(DefaultCommandLineToolConfiguration.class, ToolType.STATIC_LIB_ARCHIVER));

    public CommandLineToolSearchResult locateTool(ToolType compilerType) {
        if (compilerType == ToolType.SWIFT_COMPILER || compilerType == ToolType.LINKER) {
            return toolSearchPath.locate(compilerType, "swiftc");
        }
        if (compilerType == ToolType.STATIC_LIB_ARCHIVER) {
            return toolSearchPath.locate(compilerType, "ar");
        }
        if (compilerType == ToolType.SYMBOL_EXTRACTOR) {

    public GccCommandLineToolConfigurationInternal getTool(ToolType toolType) {
        return tools.get(toolType);
    }

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

    public Collection<GccCommandLineToolConfigurationInternal> getCompilers() {

import java.util.Map;

class GccPlatformToolProvider extends AbstractPlatformToolProvider {

    private static final Map<ToolType, String> LANGUAGE_FOR_COMPILER = ImmutableMap.of(
        ToolType.C_COMPILER, "c",
        ToolType.CPP_COMPILER, "c++",
        ToolType.OBJECTIVEC_COMPILER, "objective-c",
        ToolType.OBJECTIVECPP_COMPILER, "objective-c++"
    );

    private final ToolSearchPath toolSearchPath;

import org.gradle.nativeplatform.toolchain.internal.ToolType;

import java.util.ArrayList;
import java.util.List;

public class DefaultCommandLineToolConfiguration implements CommandLineToolConfigurationInternal {
    private final ToolType toolType;
    private List<Action<? super List<String>>> argActions = new ArrayList<Action<? super List<String>>>();

    public DefaultCommandLineToolConfiguration(ToolType toolType) {
        this.toolType = toolType;

    public CommandLineToolConfiguration getSwiftCompiler() {
        return tools.get(ToolType.SWIFT_COMPILER);
    }

    @Override
    public CommandLineToolConfiguration getLinker() {
        return tools.get(ToolType.LINKER);
    }

    @Override
    public CommandLineToolConfiguration getStaticLibArchiver() {
        return tools.get(ToolType.STATIC_LIB_ARCHIVER);
    }

    @Override

        }
        1 * toolRegistry.getTool(toolType) >> new DefaultGccCommandLineToolConfiguration(toolType, 'exe')
        1 * toolSearchPath.locate(toolType, 'exe') >> Mock(CommandLineToolSearchResult)

        where:
        toolType                       | args
        ToolType.CPP_COMPILER          | ['-x', 'c++']
        ToolType.C_COMPILER            | ['-x', 'c']
        ToolType.OBJECTIVEC_COMPILER   | ['-x', 'objective-c']

import org.gradle.api.GradleException
import org.gradle.internal.logging.text.DiagnosticsVisitor
import org.gradle.internal.os.OperatingSystem
import org.gradle.nativeplatform.toolchain.internal.ToolType
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule
import spock.lang.Specification

class ToolSearchPathTest extends Specification {

import org.gradle.nativeplatform.toolchain.internal.ToolType;

public class DefaultGccCommandLineToolConfiguration extends DefaultCommandLineToolConfiguration implements GccCommandLineToolConfigurationInternal {
    private String executable;

    public DefaultGccCommandLineToolConfiguration(ToolType toolType, String defaultExecutable) {
        super(toolType);
        this.executable = defaultExecutable;
    }