return toolSearchPath.locate(compilerType, toolRegistry.getTool(compilerType).getExecutable());
    }

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

        1 * metaDataProvider.getCompilerMetaData(_, _) >> {
            arguments[1].execute(assertingCompilerExecSpecArguments(args))
            new ComponentFound(metaData)
        }
        1 * toolRegistry.getTool(toolType) >> new DefaultGccCommandLineToolConfiguration(toolType, 'exe')
        1 * toolSearchPath.locate(toolType, 'exe') >> Mock(CommandLineToolSearchResult)
        _ * metaData.systemLibraries >> libs

        where:

import org.gradle.platform.base.internal.toolchain.ToolSearchResult;

import java.io.File;

public interface CommandLineToolSearchResult extends ToolSearchResult {
    File getTool();

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

import javax.annotation.Nullable;

@NonNullApi
public interface ToolRegistry {
    @Nullable
    GccCommandLineToolConfigurationInternal getTool(ToolType toolType);

            this.tool = tool;
        }

        @Override
        public boolean isAvailable() {
            return true;
        }

        @Override
        public File getTool() {
            return tool;
        }

        @Override
        public void explain(DiagnosticsVisitor visitor) {
        }
    }

        this.compilerProbeArgs.addAll(Arrays.asList(args));
    }

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

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

    public Collection<GccCommandLineToolConfigurationInternal> getCompilers() {

        throw failure();
    }

    @Override
    public CommandLineToolSearchResult locateTool(ToolType compilerType) {
        return this;
    }

    @Override
    public File getTool() {
        throw new UnsupportedOperationException();
    }

    @Override
    public SystemLibraries getSystemLibraries(ToolType compilerType) {
        return new EmptySystemLibraries();
    }

    }

    private CommandLineToolInvocationWorker commandLineTool(ToolType key, String exeName) {
        return new DefaultCommandLineToolInvocationWorker(key.getToolName(), toolSearchPath.locate(key, exeName).getTool(), execActionFactory);
    }

    private CommandLineToolContext context(CommandLineToolConfigurationInternal toolConfiguration) {

        os.findInPath("cc") >> null

        when:
        def result = registry.locate(ToolType.C_COMPILER, "cc")

        then:
        !result.available

        when:
        result.getTool()

        then:
        GradleException e = thrown()
        e.message == "Could not find C compiler 'cc' in system path."
    }

        }
        SearchResult<SwiftcMetadata> swiftcMetaData = compilerMetaDataProvider.getCompilerMetaData(toolSearchPath.getPath(), spec -> spec.executable(compiler.getTool()));
        result.mustBeAvailable(swiftcMetaData);
        if (!result.isAvailable()) {
            return new UnavailablePlatformToolProvider(targetPlatform.getOperatingSystem(), result);
        }