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

        return versionAwareCompiler(outputCleaningCompiler, ToolType.CPP_COMPILER);
    }

    @Override
    protected Compiler<?> createCppPCHCompiler() {
        GccCommandLineToolConfigurationInternal cppCompilerTool = toolRegistry.getTool(ToolType.CPP_COMPILER);

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

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

        visualCpp.includeDirs >> [dir1]
        windowsSdk.includeDirs >> [dir2]
        ucrt.includeDirs >> [dir3]

        expect:
        def libs = toolProvider.getSystemLibraries(ToolType.CPP_COMPILER)
        libs.includeDirs == [dir1, dir2, dir3]
    }

    def "returns compiler metadata"() {
        def vsVersion = VersionNumber.version(123)
        def vcVersion = VersionNumber.version(22)

        PlatformToolProvider provider = ((DefaultCppBinary) getBinary()).getPlatformToolProvider();
        if (provider.isAvailable()) {
            CompilerMetadata compilerMetadata = provider.getCompilerMetadata(ToolType.CPP_COMPILER);
            if (compilerMetadata instanceof VisualCppMetadata) {
                return ((VisualCppMetadata) compilerMetadata).getVisualStudioVersion();
            }
        }

        // Assume VS 2015

        platform.operatingSystem >> dummyOs
        platform.architecture >> dummyArch

        and:
        toolSearchPath.locate(ToolType.C_COMPILER, "gcc") >> compilerMissing
        toolSearchPath.locate(ToolType.CPP_COMPILER, "g++") >> missing
        toolSearchPath.locate(ToolType.OBJECTIVEC_COMPILER, "gcc") >> missing
        toolSearchPath.locate(ToolType.OBJECTIVECPP_COMPILER, "g++") >> missing

        expect:

        1 * toolSearchPath.locate(toolType, 'exe') >> Mock(CommandLineToolSearchResult)
        _ * metaData.systemLibraries >> libs

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

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"),
    WINDOW_RESOURCES_COMPILER("Windows resources compiler"),

    }

    @Override
    public CommandLineToolSearchResult locateTool(ToolType compilerType) {
        switch (compilerType) {
            case C_COMPILER:
            case CPP_COMPILER:
                return new CommandLineToolSearchResult() {
                    @Override
                    public File getTool() {
                        return visualCpp.getCompilerExecutable();

                if (toolProvider instanceof UnsupportedPlatformToolProvider) {
                    return toolProvider;
                }
                ToolSearchResult cppCompiler = toolProvider.locateTool(ToolType.CPP_COMPILER);
                if (cppCompiler.isAvailable()) {
                    return toolProvider;
                }
                // No C++ compiler, complain about it