final WorkerLeaseService workerLeaseService = serviceRegistry.get(WorkerLeaseService.class);

            toolChainRegistry.registerFactory(VisualCpp.class, new NamedDomainObjectFactory<VisualCpp>() {
                @Override
                public VisualCpp create(String name) {

            if (toolChain in Gcc) {
                cCompiler.args "-O2"
                linker.args "-Xlinker", "-S"
            }
            if (toolChain in VisualCpp) {
                cCompiler.args "/Zi"
                linker.args "/DEBUG"
            }
        }
    }
}
// end::compiler-args[]

// tag::all-shared-libraries[]

        if (!result.isAvailable()) {
            return new UnavailablePlatformToolProvider(targetPlatform.getOperatingSystem(), result);
        }

        VisualCpp platformVisualCpp = visualCpp == null ? null : visualCpp.forPlatform(targetPlatform);
        if (platformVisualCpp == null) {

        super(file, toolChain)
    }

    TestFile getLinkFile() {
        if (toolChain.visualCpp) {
            return file.withExtension(".lib")
        }
        return file
    }

    TestFile getStrippedLinkFile() {
        if (toolChain.visualCpp) {
            return file.withExtension(".lib")
        }
        return strippedRuntimeFile
    }

    @Override

    }

    String withLinkLibrarySuffix(Object path) {
        return path + (toolChain.visualCpp ? OperatingSystem.current().linkLibrarySuffix : OperatingSystem.current().sharedLibrarySuffix)
    }

    String linkLibraryName(Object path) {
        return toolChain.visualCpp ? OperatingSystem.current().getLinkLibraryName(path.toString()) : OperatingSystem.current().getSharedLibraryName(path.toString())
    }

    void assertDebugFileExists() {
        if (toolChain.visualCpp) {
            getSymbolFile().assertIsFile()
        }
    }

    // Does nothing when tool chain does not generate a separate debug file
    void assertDebugFileDoesNotExist() {
        if (toolChain.visualCpp) {
            getSymbolFile().assertDoesNotExist()
        }
    }

        }
        DefaultNativePlatform targetPlatform = new DefaultNativePlatform("default");
        def visualCpp = vsInstall.visualCpp.forPlatform(targetPlatform)
        vcBin = visualCpp.binDir
        vcPath = visualCpp.path.join(';')
    }

    static @Nullable VisualStudioInstall findVisualStudio() {

        result.component.name == "Visual Studio 12.0.0"
        result.component.version == VersionNumber.parse("12.0")
        result.component.baseDir == dir2
        result.component.visualCpp.name == "Visual C++ 12.0.0"
        result.component.visualCpp.version == VersionNumber.parse("12.0")
    }

    def "use highest visual studio version found from the command line"() {
        def dir1 = vsDir("vs1")
        def dir2 = vsDir("vs2")

            List<String> getExtract() {
                if (toolChainUnderTest.visualCpp) {
                    return []
                } else {
                    return [withProject("extractSymbolsRelease${variant}")]
                }
            }

            List<String> getStrip() {
                if (toolChainUnderTest.visualCpp) {
                    return []
                } else {

// tag::build-type-config[]
model {
    binaries {
        all {
            if (toolChain in Gcc && buildType == buildTypes.debug) {
                cppCompiler.args "-g"
            }
            if (toolChain in VisualCpp && buildType == buildTypes.debug) {
                cppCompiler.args '/Zi'
                cppCompiler.define 'DEBUG'
                linker.args '/DEBUG'
            }
        }
    }
}