return toolProvider;
                }
                ToolSearchResult cCompiler = toolProvider.locateTool(ToolType.C_COMPILER);
                if (cCompiler.isAvailable()) {
                    return toolProvider;
                }
                ToolSearchResult compiler = toolProvider.locateTool(ToolType.CPP_COMPILER);
                if (compiler.isAvailable()) {
                    return toolProvider;

        def provider = new UnavailablePlatformToolProvider(Stub(OperatingSystemInternal), new ToolChainAvailability().unavailable("don't know how to build this thing"))

        expect:
        def toolResult = provider.locateTool(ToolType.C_COMPILER)
        !toolResult.available
        def formatter = new TreeFormatter()
        toolResult.explain(formatter)
        formatter.toString() == "don't know how to build this thing"
    }

    String getLibrarySymbolFileName(String libraryPath);

    CompilerMetadata getCompilerMetadata(ToolType compilerType);

    SystemLibraries getSystemLibraries(ToolType compilerType);

    CommandLineToolSearchResult locateTool(ToolType compilerType);

    boolean isSupported();

    }

    @Override
    public <T extends CompileSpec> Compiler<T> newCompiler(Class<T> specType) {
        throw failure();
    }

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

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

    @Override

        @Override
        SystemLibraries getSystemLibraries(ToolType compilerType) {
            throw new UnsupportedOperationException()
        }

        @Override
        CommandLineToolSearchResult locateTool(ToolType compilerType) {
            throw new UnsupportedOperationException()
        }
    }

            List<String> additionalArgs = args(compileTask.getCompilerArgs().get());
            CommandLineToolSearchResult compilerLookup = platformToolProvider.locateTool(ToolType.CPP_COMPILER);
            File compilerExe = compilerLookup.isAvailable() ? compilerLookup.getTool() : null;
            LaunchableGradleTask compileTaskModel = buildLaunchableTask(projectIdentifier, compileTask);

        this.execActionFactory = execActionFactory;
        this.workerLeaseService = workerLeaseService;
        this.swiftcMetaData = swiftcMetaData;
    }

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

                if (!toolProvider.isAvailable()) {
                    return toolProvider;
                }
                ToolSearchResult cppCompiler = toolProvider.locateTool(ToolType.CPP_COMPILER);
                if (!cppCompiler.isAvailable()) {
                    return new UnavailablePlatformToolProvider(targetMachine.getOperatingSystem(), cppCompiler);
                }

        @Override
        SystemLibraries getSystemLibraries(ToolType compilerType) {
            throw new UnsupportedOperationException()
        }

        @Override
        CommandLineToolSearchResult locateTool(ToolType compilerType) {
            throw new UnsupportedOperationException()
        }
    }

        this.execActionFactory = execActionFactory;
        this.workerLeaseService = workerLeaseService;
        this.metadataProvider = metadataProvider;
    }

    @Override
    public CommandLineToolSearchResult locateTool(ToolType compilerType) {
        return toolSearchPath.locate(compilerType, toolRegistry.getTool(compilerType).getExecutable());
    }

    @Override
    protected Compiler<CppCompileSpec> createCppCompiler() {