def binary = new File("any")
        when:
        def metadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        interaction compilerShouldBeExecuted

        when:
        def newMetadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        0 * _
        newMetadata.is(metadata)

        where:

        platform.architecture >> dummyArch

        and:
        toolSearchPath.locate(ToolType.CPP_COMPILER, "g++") >> compilerMissing
        toolSearchPath.locate(_, _) >> tool
        metaDataProvider.getCompilerMetaData(_, _) >> correctCompiler

        expect:
        def platformToolChain = toolChain.select(NativeLanguage.CPP, platform)
        !platformToolChain.available

        ToolType.ASSEMBLER             | []
    }

    def "gets compiler metadata from the provider for #toolType.toolName"() {
        when:
        platformToolProvider.getCompilerMetadata(toolType)

        then:
        1 * metaDataProvider.getCompilerMetaData(_, _) >> {
            arguments[1].execute(assertingCompilerExecSpecArguments(args))
            Mock(SearchResult)
        }

        and:
        def metadataProvider = new SwiftcMetadataProvider(execActionFactory)
        def binary = new File("swiftc")

        when:
        def result = metadataProvider.getCompilerMetaData([]) { it.executable(binary) }

        then:
        1 * execActionFactory.newExecAction() >> action
        1 * action.execute() >> execResult
        1 * execResult.getExitValue() >> 1

        and:

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

import java.io.File;
import java.util.List;

public interface CompilerMetaDataProvider<T extends CompilerMetadata> {

    SearchResult<T> getCompilerMetaData(List<File> searchPath, Action<? super CompilerExecSpec> configureAction);

    CompilerType getCompilerType();

    interface CompilerExecSpec {
        CompilerExecSpec environment(String key, String value);

        private CachingCompilerMetaDataProvider(CompilerMetaDataProvider<T> delegate) {
            this.delegate = delegate;
        }

        @Override
        public SearchResult<T> getCompilerMetaData(List<File> path, Action<? super CompilerExecSpec> configureAction) {
            AbstractMetadataProvider.DefaultCompilerExecSpec execSpec = new AbstractMetadataProvider.DefaultCompilerExecSpec();

    String getStaticLibraryName(String libraryPath);

    String getExecutableSymbolFileName(String executablePath);

    String getLibrarySymbolFileName(String libraryPath);

    CompilerMetadata getCompilerMetadata(ToolType compilerType);

    SystemLibraries getSystemLibraries(ToolType compilerType);

    CommandLineToolSearchResult locateTool(ToolType compilerType);

    boolean isSupported();

        then:
        GradleException e = thrown()
        e.message == "broken"
    }

    def "throws failure when attempting to get compiler metadata"() {
        when:
        toolChain.getCompilerMetadata()

        then:
        GradleException e = thrown()
        e.message == "broken"
    }

        def vcVersion = VersionNumber.version(22)
        visualStudioInstall.version >> vsVersion
        visualCpp.implementationVersion >> vcVersion

        expect:
        def metadata = toolProvider.getCompilerMetadata(ToolType.CPP_COMPILER)
        metadata.visualStudioVersion == vsVersion
        metadata.version == vcVersion
        metadata.vendor == "Microsoft"
    }

            this.delegate = delegate;
        }

        @Override
        public SearchResult<GccMetadata> getCompilerMetaData(List<File> searchPath, Action<? super CompilerExecSpec> configureAction) {
            return delegate.getCompilerMetaData(searchPath, execSpec -> {
                execSpec.args(compilerProbeArgs);
                configureAction.execute(execSpec);
            });
        }