}

    void assertRegistryNotWorldReadable() {
        def registryFile = new DaemonDir(context.daemonRegistryDir).registry
        if (OperatingSystem.current().isLinux() || OperatingSystem.current().isMacOsX()) {
            def stat = NativeServicesTestFixture.instance.get(Stat)
            assert stat.getUnixMode(registryFile) == 0600 // user read-write

    }

    private static int getMaxCommandLineLength() {
        int defaultMax = MAX_COMMAND_LINE_LENGTH_NIX;
        if (OperatingSystem.current().isMacOsX()) {
            defaultMax = MAX_COMMAND_LINE_LENGTH_OSX;
        } else if (OperatingSystem.current().isWindows()) {
            defaultMax = MAX_COMMAND_LINE_LENGTH_WINDOWS;
        }
        // in chars

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:

    private final WorkInputListeners inputsListeners;
    private final FileChangeListeners fileChangeListeners;
    private final BuildRequestMetaData requestMetaData;
    private final OperatingSystem operatingSystem;
    private final BuildCancellationToken cancellationToken;
    private final DeploymentRegistryInternal deploymentRegistry;
    private final ListenerManager listenerManager;

            OperatingSystem operatingSystem,
            NativeCapabilities nativeCapabilities,
            Predicate<String> immutableLocationsFilter
        ) {
            if (nativeCapabilities.useFileSystemWatching()) {
                try {
                    if (operatingSystem.isMacOsX()) {

        }

        return result
    }

    private static int getMaxArgs() {
        switch (OperatingSystem.current()) {
            case OperatingSystem.WINDOWS:
                return LongCommandLineDetectionUtil.MAX_COMMAND_LINE_LENGTH_WINDOWS
            case OperatingSystem.MAC_OS:
                return LongCommandLineDetectionUtil.MAX_COMMAND_LINE_LENGTH_OSX
            default:

import org.gradle.api.internal.artifacts.ivyservice.projectmodule.ProjectPublicationRegistry
import org.gradle.api.provider.Property
import org.gradle.internal.os.OperatingSystem
import org.gradle.language.cpp.CppPlatform
import org.gradle.language.cpp.internal.DefaultCppApplication
import org.gradle.language.cpp.internal.DefaultCppBinary
import org.gradle.language.cpp.internal.DefaultCppExecutable

import org.gradle.exemplar.test.normalizer.OutputNormalizer
import org.gradle.internal.os.OperatingSystem
import org.gradle.platform.internal.DefaultBuildPlatform

/**
 * This normalizer converts toolchain error message so it doesn't contain platform-specific information.
 */
class PlatformInOutputNormalizer implements OutputNormalizer {
    def static internalOs = OperatingSystem.current()
    def static os = DefaultBuildPlatform.getOperatingSystem(internalOs)

package org.gradle.integtests.fixtures

import org.gradle.api.internal.file.TestFiles
import org.gradle.internal.os.OperatingSystem

class KillProcessAvailability {

    final static CAN_KILL

    static {
        if (OperatingSystem.current().isUnix()) {
            CAN_KILL = true
        } else if (OperatingSystem.current().isWindows()) {
            //On some windowses, taskkill does not seem to work when triggered from java

        if (toolChains == null) {
            List<ToolChainCandidate> compilers = new ArrayList<>();
            if (OperatingSystem.current().isWindows()) {
                compilers.addAll(findVisualCpps());
                compilers.add(findMinGW());
            } else if (OperatingSystem.current().isMacOsX()) {
                compilers.addAll(findClangs(true));
                compilers.addAll(findGccs(false));