package org.gradle.nativeplatform.fixtures

import org.gradle.internal.os.OperatingSystem
import org.gradle.test.fixtures.file.ExecOutput
import org.gradle.test.fixtures.file.TestFile

class NativeInstallationFixture {
    private final TestFile installDir
    private final OperatingSystem os

    NativeInstallationFixture(TestFile installDir, OperatingSystem os) {
        this.installDir = installDir
        this.os = os
    }

 */

package org.gradle.nativeplatform.toolchain

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache
import org.gradle.internal.os.OperatingSystem
import org.gradle.nativeplatform.fixtures.AvailableToolChains
import org.gradle.nativeplatform.fixtures.RequiresInstalledToolChain
import org.gradle.nativeplatform.fixtures.ToolChainRequirement

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;

        linkDebug.debuggable

        def installDebug = project.tasks.installDebug
        installDebug instanceof InstallExecutable
        installDebug.installDirectory.get().asFile == projectDir.file("build/install/main/debug")
        installDebug.runScriptFile.get().getAsFile().name == OperatingSystem.current().getScriptName("testApp")

            testProject: testProject,
            testGroup: testGroup,
            jvm: Jvm.current().toString(),
            host: InetAddress.getLocalHost().getHostName(),
            operatingSystem: OperatingSystem.current().toString(),
            versionUnderTest: GradleVersion.current().getVersion(),
            vcsBranch: Git.current().branchName,
            vcsCommits: [Git.current().commitId],

    SetSystemProperties sysProp = new SetSystemProperties()
    OperatingSystem os = Mock() {
        getExecutableName(_) >> { String name ->
            return "${name}.exe"
        }
    }
    OperatingSystem theOs = OperatingSystem.current()

    Jvm getJvm() {
        new Jvm(os)
    }

    def setup() {
        JavaVersion.resetCurrent()
        OperatingSystem.resetCurrent()
    }

    def cleanup() {

        this.vcsCommits = vcsCommits;
    }

    public String getOperatingSystem() {
        return operatingSystem;
    }

    public void setOperatingSystem(String operatingSystem) {
        this.operatingSystem = operatingSystem;
    }

    public String getJvm() {
        return jvm;
    }

    public void setJvm(String jvm) {
        this.jvm = jvm;

import org.gradle.internal.os.OperatingSystem;

import java.lang.reflect.Field;
import java.util.Map;

/**
 * Uses reflection to update private environment state
 */
public class ReflectiveEnvironment {

    public void unsetenv(String name) {
        Map<String, String> map = getEnv();
        map.remove(name);
        if (OperatingSystem.current().isWindows()) {

                    def libName = targetPlatform.operatingSystem.windows ? 'util.lib' : 'libutil.a'
                    staticLibraryFile = file("3rd-party-lib/util/build/libs/util/static/${buildType.name}/${libName}")
                }
                binaries.withType(SharedLibraryBinary) {
                    def os = targetPlatform.operatingSystem

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.initialization

import org.gradle.internal.os.OperatingSystem


class DefaultSettingsRootFileSystemTest extends DefaultSettingsCommonTest {

    def setup() {
       createSettings('/')
    }

    def 'root project name generation in file system root'() {