import static org.gradle.performance.annotations.ScenarioType.PER_DAY
import static org.gradle.performance.results.OperatingSystem.LINUX
import static org.gradle.performance.results.OperatingSystem.MAC_OS
import static org.gradle.performance.results.OperatingSystem.WINDOWS

@RunFor(
    @Scenario(type = PER_DAY, operatingSystems = [LINUX, MAC_OS, WINDOWS], testProjects = ["largeEmptyMultiProjectDeclarativeDsl"])
)

        @Provides
        protected DefaultBuildPlatform createBuildPlatform(ObjectFactory objectFactory, SystemInfo systemInfo, OperatingSystem operatingSystem) {
            return objectFactory.newInstance(DefaultBuildPlatform.class, systemInfo, operatingSystem);
        }

        @Provides
        protected DefaultJavaToolchainResolverRegistry createJavaToolchainResolverRegistry(
            Gradle gradle,

    }

    def "makes a ProcessEnvironment available"() {
        expect:
        services.get(ProcessEnvironment) != null
    }

    def "makes an OperatingSystem available"() {
        expect:
        services.get(OperatingSystem) != null
    }

    def "makes a FileSystem available"() {
        expect:
        services.get(FileSystem) != null
        services.get(Chmod) != null

    @Provides
    FileSystem createFileSystem(
        GenericFileSystem.Factory genericFileSystemFactory,
        OperatingSystem operatingSystem,
        PosixFiles posixFiles,
        FileMetadataAccessor metadataAccessor,
        TemporaryFileProvider temporaryFileProvider
    ) {
        if (operatingSystem.isWindows()) {
            final Symlink symlink = createWindowsJdkSymlink();

    }
    val jvm = org.gradle.internal.jvm.Jvm.current()
    val javaVersion = JavaVersion.current()
    val isWindows = OperatingSystem.current().isWindows
    val isLinux = OperatingSystem.current().isLinux
    val isMacOsX = OperatingSystem.current().isMacOsX
    val isIntel: Boolean = architecture == "x86_64" || architecture == "x86"
    val isSlowInternetConnection

import org.gradle.internal.os.OperatingSystem;

import java.io.File;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class WindowsInstallationSupplier implements InstallationSupplier {

    private final WindowsRegistry windowsRegistry;
    private final OperatingSystem os;

import org.gradle.internal.os.OperatingSystem
import spock.lang.Specification

class WindowsInstallationSupplierTest extends Specification {

    def registry = Mock(WindowsRegistry)

    def "no detection for non-windows os"() {
        given:
        def supplier = createSupplier(OperatingSystem.MAC_OS)

        when:
        supplier.get()

        then:

        }

        @Provides
        VswhereVersionLocator createVswhereVersionLocator(WindowsRegistry windowsRegistry, OperatingSystem os) {
            return new DefaultVswhereVersionLocator(windowsRegistry, os);
        }

        @Provides
        SystemPathVersionLocator createSystemPathVersionLocator(OperatingSystem os, VisualStudioMetaDataProvider versionDeterminer) {
            return new SystemPathVersionLocator(os, versionDeterminer);

import org.gradle.internal.os.OperatingSystem
import org.gradle.process.ExecResult
import org.gradle.process.internal.ExecHandle
import org.gradle.process.internal.ExecHandleBuilder

class ScriptExecuter {
    @Delegate
    ExecHandleBuilder builder = TestFiles.execHandleFactory().newExec()

    @Override
    ExecHandle build() {
        if (OperatingSystem.current().isWindows()) {

import org.gradle.api.provider.Provider
import org.gradle.api.provider.ProviderFactory
import org.gradle.api.services.BuildService
import org.gradle.api.services.BuildServiceParameters
import org.gradle.internal.os.OperatingSystem
import javax.inject.Inject


abstract class BuildEnvironmentService : BuildService<BuildEnvironmentService.Parameters> {

    interface Parameters : BuildServiceParameters {