"os/exec"
	"path/filepath"
	"testing"
)

func TestGoCommandExists(t *testing.T) {
	got, err := exec.LookPath("go")
	if err != nil {
		t.Fatal(err)
	}

	want := filepath.Join(os.Getenv("GOROOT"), "bin", "go" + os.Getenv("GOEXE"))
	if got != want {
		t.Fatalf(`exec.LookPath("go") = %q; want %q`, got, want)
	}
}
-- $WORK/bin/README.txt --

 */
@LocalOnly(because = "Needs Android environment")
abstract class AbstractKotlinPluginAndroidSmokeTest extends AbstractSmokeTest implements RunnerFactory {
    abstract String getSampleName()
    abstract GradleDsl getDSL()

    VersionNumber kotlinPluginVersion

// license that can be found in the LICENSE file.

// Windows environment variables.

package windows

import (
	"syscall"
	"unsafe"
)

func Getenv(key string) (value string, found bool) {
	return syscall.Getenv(key)
}

func Setenv(key, value string) error {
	return syscall.Setenv(key, value)
}

func Clearenv() {
	syscall.Clearenv()
}

func Environ() []string {

                Properties properties = new Properties()
                properties.JAVA_HOME = String.valueOf(System.getenv('JAVA_HOME'))
                properties.GRADLE_USER_HOME = String.valueOf(gradle.gradleUserHomeDir.absolutePath)
                properties.GRADLE_OPTS = String.valueOf(System.getenv('GRADLE_OPTS'))
                return properties
            }

            void assertEquals(key, expected, actual) {

			fprintf(stderr, "SIGSEGV caught in C unexpectedly\n");
			exit(1);
		}
		fprintf(stdout, "OK\n");
		exit(0);  // success
	}
}

static void __attribute__ ((constructor)) sigsetup(void) {
	if (getenv("GO_TEST_CGOSIGFWD") == NULL) {
		return;
	}

	struct sigaction act;

	memset(&act, 0, sizeof act);
	act.sa_handler = segvhandler;
	sigaction(SIGSEGV, &act, NULL);
}
*/
import "C"

        then:
        !allArgs.toString().contains("-Porg.gradle.java.installations.auto-download")
    }

    def "does not allow you to use startBuildProcessInDebugger on CI"() {
        Assume.assumeTrue(System.getenv().containsKey("CI"))
        when:
        executer.startBuildProcessInDebugger(true)
        executer.getAllArgs()
        then:
        def e = thrown(IllegalArgumentException)

func Commands() [][]string {
	var cmds [][]string
	if exe := os.Getenv("BROWSER"); exe != "" {
		cmds = append(cmds, []string{exe})
	}
	switch runtime.GOOS {
	case "darwin":
		cmds = append(cmds, []string{"/usr/bin/open"})
	case "windows":
		cmds = append(cmds, []string{"cmd", "/c", "start"})
	default:
		if os.Getenv("DISPLAY") != "" {
			// xdg-open is only for use in a desktop environment.

  __path__ = [_tf_api_dir]
elif _tf_api_dir not in __path__:
  __path__.append(_tf_api_dir)

# Hook external TensorFlow modules.

# Load tensorflow-io-gcs-filesystem if enabled
if (_os.getenv("TF_USE_MODULAR_FILESYSTEM", "0") == "true" or
    _os.getenv("TF_USE_MODULAR_FILESYSTEM", "0") == "1"):
  import tensorflow_io_gcs_filesystem as _tensorflow_io_gcs_filesystem

# Lazy-load Keras v2/3.
_tf_uses_legacy_keras = (

    val isCiServer = CI_ENVIRONMENT_VARIABLE in System.getenv()
    val isTravis = "TRAVIS" in System.getenv()
    val isGhActions = "GITHUB_ACTIONS" in System.getenv()
    val isTeamCity = "TEAMCITY_VERSION" in System.getenv()
    val isTeamCityParallelTestsEnabled
        get() = "TEAMCITY_PARALLEL_TESTS_ENABLED" in System.getenv()
    val isCodeQl: Boolean by lazy {

    private static final String ENV_VARIABLE_NAME = "ANDROID_SDK_ROOT"

    static void assumeIsSet() {
        assumeThat(NO_ENV_MESSAGE, System.getenv(ENV_VARIABLE_NAME), notNullValue())
    }

    static void assertIsSet() {
        assertThat(NO_ENV_MESSAGE, System.getenv(ENV_VARIABLE_NAME), notNullValue())
    }

    private static final String NO_ENV_MESSAGE = """