eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.6
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate

            </tr>
            <tr>
                <td>libs</td>
            </tr>
            <tr>
                <td>toolChain</td>
            </tr>
            <tr>
                <td>targetPlatform</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>

}
"""
        settingsFile << "rootProject.name = 'test'"
    }

    private void useStandardConfig() {
        buildFile << """
model {
    components {
        hello(NativeLibrarySpec) {
            targetPlatform "x86"
        }
    }
    testSuites {
        helloTest(GoogleTestTestSuiteSpec) {
            testing \$.components.hello
        }
    }
}
tasks.withType(RunTestExecutable) {

                binaries.withType(StaticLibraryBinary) {
                    def libName = targetPlatform.operatingSystem.windows ? 'hello.lib' : 'libhello.a'
                    staticLibraryFile = file("libs/build/libs/hello/static/english/\${libName}")
                }
                binaries.withType(SharedLibraryBinary) {
                    def os = targetPlatform.operatingSystem
                    def baseDir = "libs/build/libs/hello/shared/french"

                    this.afterCallback = afterCallback
                }

                @Override
                PlatformToolProvider select(NativePlatformInternal targetPlatform) {
                    def toolProvider = delegate.select(targetPlatform)
                    if (! decorated.contains(toolProvider)) {
                        Field workerLeaseService = toolProvider.getClass().getDeclaredField("workerLeaseService")

        super(names, objectFactory, baseName, sourceFiles, componentHeaderDirs, configurations, implementation, targetPlatform, toolChain, platformToolProvider, identity);
        this.executableFile = objectFactory.fileProperty();

        if (vsInstall == null) {
            throw new UnsupportedOperationException("Visual Studio is unavailable on this system.")
        }
        DefaultNativePlatform targetPlatform = new DefaultNativePlatform("default");
        def visualCpp = vsInstall.visualCpp.forPlatform(targetPlatform)
        vcBin = visualCpp.binDir
        vcPath = visualCpp.path.join(';')
    }

    static @Nullable VisualStudioInstall findVisualStudio() {

public interface TargetPlatformConfiguration {
    /**
     * Returns whether a platform is supported or not.
     */
    boolean supportsPlatform(NativePlatformInternal targetPlatform);

    /**
     *  applies a platform specific toolchain configuration
     */
    void apply(DefaultGccPlatformToolChain platformToolChain);

        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>targetPlatform</td>
            </tr>
        </table>
    </section>

        }

        buildFile << """
model {
    platforms {
        x86 {
            architecture "i386"
        }
    }
    components {
        main(NativeExecutableSpec) {
            targetPlatform "x86"
            binaries.all {
                linker.args "-v"
            }
        }
    }
}
            """
        then:
        succeeds "mainExecutable"