}
    }
}

def findGoogleTestCoreLibForPlatform(Platform platform) {
    if (platform.operatingSystem.windows) {
        return "vs2013/gtest.lib"
//        return "vs2013/gtest-core.lib"
//        return "cygwin/gtest-core.lib"
//        return "mingw/gtest-core.lib"
    } else if (platform.operatingSystem.macOsX) {
        return "osx/libgtest.a"
    } else {
        return "linux/libgtest.a"
    }

package org.gradle.jvm.toolchain.internal


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

class OsXInstallationSupplierTest extends Specification {
    def osxJavaHomeCommand = Mock(OsXJavaHomeCommand)

    def "supplies no installations for absent output"() {
        given:
        def supplier = new OsXInstallationSupplier(OperatingSystem.MAC_OS, osxJavaHomeCommand)
        osxJavaHomeCommand.findJavaHomes() >> []

    private static final Logger LOGGER = Logging.getLogger(SystemPathVersionLocator.class);
    private final OperatingSystem os;
    private final VisualStudioMetaDataProvider versionDeterminer;

    public SystemPathVersionLocator(OperatingSystem os, VisualStudioMetaDataProvider versionDeterminer) {
        this.os = os;
        this.versionDeterminer = versionDeterminer;
    }

    @Nonnull

    }
    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 net.rubygrapefruit.platform.WindowsRegistry;
import org.gradle.internal.os.OperatingSystem;

import java.io.File;

public class DefaultVswhereVersionLocator implements VswhereVersionLocator {
    private final WindowsRegistry windowsRegistry;
    private final OperatingSystem os;

    private static final String[] PROGRAM_FILES_KEYS = {
        "ProgramFilesDir",
        "ProgramFilesDir (x86)"

 * limitations under the License.
 */

package org.gradle.jvm.toolchain.internal

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

class DefaultToolchainConfigurationTest extends Specification {
    private SystemProperties systemProperties = Stub()
    private Map<String, String> environment = [:]

        1 * queue.add(invocation)
        1 * queue.setLogLocation(LOG_LOCATION)
        0 * _
    }

    List<String> getSoNameProp(def value) {
        if (OperatingSystem.current().isWindows()) {
            return []
        }
        if (OperatingSystem.current().isMacOsX()) {
            return ["-Wl,-install_name,${value}"]
        }
        return ["-Wl,-soname,${value}"]
    }

            return Lists.newArrayList("-o", outputFilePath, inputFilePath);
        }
    };

    private static final OperatingSystem OS = OperatingSystem.current();

    private final String executable;
    private final List<String> arguments;
    private final String extension;

        link.debuggable

        def install = project.tasks.installTest
        install instanceof InstallExecutable
        install.installDirectory.get().asFile == project.file("build/install/test")
        install.runScriptFile.get().asFile.name == OperatingSystem.current().getScriptName("someAppTest")
    }

	KubeletVersion          *string `json:"kubeletVersion,omitempty"`
	KubeProxyVersion        *string `json:"kubeProxyVersion,omitempty"`
	OperatingSystem         *string `json:"operatingSystem,omitempty"`
	Architecture            *string `json:"architecture,omitempty"`
}

// NodeSystemInfoApplyConfiguration constructs an declarative configuration of the NodeSystemInfo type for use with