}
    )
}
// end::ignoreSystemProperties[]

// tag::environment[]
tasks.integTest {
    inputs.property("langEnvironment") {
        System.getenv("LANG")
    }
}

	if err != nil {
		return nil, fmt.Errorf("user: %s", err)
	}

	uname := string(ubytes)

	u := &User{
		Uid:      uname,
		Gid:      uname,
		Username: uname,
		Name:     uname,
		HomeDir:  os.Getenv("home"),
	}

	return u, nil
}

func lookupUser(username string) (*User, error) {
	return nil, syscall.EPLAN9
}

func lookupUserId(uid string) (*User, error) {
	return nil, syscall.EPLAN9
}

// has forced / to be shared
func TestUnshareMountNameSpace(t *testing.T) {
	const mountNotSupported = "mount is not supported: " // Output prefix indicating a test skip.
	if os.Getenv("GO_WANT_HELPER_PROCESS") == "1" {
		dir := flag.Args()[0]
		err := syscall.Mount("none", dir, "proc", 0, "")
		if testenv.SyscallIsNotSupported(err) {
			fmt.Print(mountNotSupported, err)
		} else if err != nil {

		}
	}, nil
}

func init() {
	if os.Getenv("GO_NET_TEST_TRANSFER") == "" {
		return
	}
	defer os.Exit(0)

	f := os.NewFile(uintptr(3), "splice-test-conn")
	defer f.Close()

	conn, err := FileConn(f)
	if err != nil {
		log.Fatal(err)
	}

	var chunkSize int
	if chunkSize, err = strconv.Atoi(os.Getenv("GO_NET_TEST_TRANSFER_CHUNK_SIZE")); err != nil {
		log.Fatal(err)
	}

        // We can't "unset" the variable with the API executer provides, but it isn't necessary, thanks to the filtering in
        // build-logic/jvm/src/main/kotlin/gradlebuild/propagated-env-variables.kt
        if (System.getenv().containsKey(key)) {
            throw new IllegalStateException("Environment variable $key is present for this process and may affect tests")
        }
    }

    }

    // Called by generated code.
    public static String getenv(String key, String consumer) {
        String value = System.getenv(key);
        envVariableQueried(key, value, consumer);
        return value;
    }

    // Called by generated code.
    public static Map<String, String> getenv(String consumer) {

	if err != nil {
		t.Fatal(err)
	}
	if !ps.Success() {
		t.Fatalf("script failed: %v", err)
	}
}

func TestExternalFile(t *testing.T) {
	os.Open(os.Getenv("TEST_EXTERNAL_FILE"))
	_, err := os.Stat(os.Getenv("TEST_EXTERNAL_FILE"))
	if err != nil {
		t.Fatal(err)
	}
}

func TestOSArgs(t *testing.T) {
	t.Log(os.Args)
}

func TestBenchtime(t *testing.T) {
}

	"path/filepath"
	"syscall"
	"testing"
	"time"
)

// TestUsingVDSO tests that we are actually using the VDSO to fetch
// the time.
func TestUsingVDSO(t *testing.T) {
	const calls = 100

	if os.Getenv("GO_WANT_HELPER_PROCESS") == "1" {
		// Fetch the time a lot.
		var total int64
		for i := 0; i < calls; i++ {
			total += time.Now().UnixNano()
		}
		os.Exit(0)
	}

	t.Parallel()

        }.get()

        then:
        1 * execOperations.exec(_) >> { Action<? super ExecSpec> action -> action.execute(spec) }
        spec.getCommandLine() == ["echo", "hello"]
        spec.environment == System.getenv()
    }

    def "full environment is propagated to execOperations"() {
        given:
        def spec = specFactory.newExecAction()

        when:
        createProviderOf(ProcessOutputValueSource.class) {

		}
		return matches
	case *listener.ListenerFilterChainMatchPredicate_DestinationPortRange:
		return int32(port) >= r.DestinationPortRange.GetStart() && int32(port) < r.DestinationPortRange.GetEnd()
	default:
		panic("unsupported predicate")
	}