fmt.Fprintf(w, "<details><summary><code>go env</code> Output</summary><br><pre>\n")
	fmt.Fprintf(w, "$ go env\n")
	printGoEnv(w)
	printGoDetails(w)
	printOSDetails(w)
	printCDetails(w)
	fmt.Fprintf(w, "</pre></details>\n\n")
}

func printGoEnv(w io.Writer) {
	env := envcmd.MkEnv()
	env = append(env, envcmd.ExtraEnvVars()...)

# to a user's environment.
go help telemetry
env TEST_TELEMETRY_DIR=

# Set userconfig dir, which is determined by os.UserConfigDir.
# The telemetry dir is determined using that.
mkdir $WORK/userconfig
env AppData=$WORK\userconfig # windows
[GOOS:windows] env userconfig=$AppData
env HOME=$WORK/userconfig # darwin,unix,ios
[GOOS:darwin] env userconfig=$HOME'/Library/Application Support'
[GOOS:ios] env userconfig=$HOME'/Library/Application Support'

# Test query for non-defaults in the env

env GOROOT=./a
env GOTOOLCHAIN=local
env GOSUMDB=nodefault
env GOPROXY=nodefault
env GO111MODULE=auto
env CGO_CFLAGS=nodefault
env CGO_CPPFLAGS=nodefault

go env -changed
# linux output like GOTOOLCHAIN='local'
# windows output like GOTOOLCHAIN=local
stdout 'GOTOOLCHAIN=''?local''?'
stdout 'GOSUMDB=''?nodefault''?'
stdout 'GOPROXY=''?nodefault''?'
stdout 'GO111MODULE=''?auto''?'

stderr 'go: downloading go1.20 '


# check for invalid GOTOOLCHAIN
env GOTOOLCHAIN=go1.14
go version
stdout 'go1.14'

env GOTOOLCHAIN=go1.20
! go version
stderr 'go: downloading go1.20 '

env GOTOOLCHAIN=go1.21
! go version
stderr 'go: invalid toolchain: go1.21 is a language version but not a toolchain version \(go1.21.x\)'

env GOTOOLCHAIN=go1.22
! go version

		})
	if err != nil {
		t.Fatalf("fail to create env set: %v", err)
	}
	env, err := envSet.Env(environment.StoredExpressions)
	if err != nil {
		t.Fatalf("fail to setup env: %v", env)
	}
	return env
}

// mustCreateEnvWithOptional creates the default env for testing, with given option,
// and set up the optional library with default configuration.
// it fatally fails the test if the env fails to set up.

  return tmp_fname;
}

absl::StatusOr<std::string> GetLocalTmpFileName() {
  return GetLocalTmpFileName(tsl::Env::Default());
}

absl::StatusOr<std::string> CreateTmpDir(tsl::Env* const env) {
  TF_ASSIGN_OR_RETURN(std::string tmp_dir, GetLocalTmpFileName(env));

  if (!env->RecursivelyCreateDir(tmp_dir).ok()) {
    return absl::InternalError(
        absl::StrFormat("Failed to create tmp dir: '%s'", tmp_dir));
  }

  return tmp_dir;

	v, err = compileAndRun(env, activation, exp)
	if err != nil {
		t.Fatalf("%q: %v", exp, err)
	}
	if v.Value().(bool) != false {
		t.Errorf("%q: wrong result: %v", exp, v.Value())
	}
}

type testActivation struct {
	variables *MapValue
}

func compileAndRun(env *cel.Env, activation *testActivation, exp string) (ref.Val, error) {
	ast, issues := env.Compile(exp)
	if issues != nil {

// `tsl::Env::Default` is used to generate the name.
absl::StatusOr<std::string> GetLocalTmpFileName();

// Creates a temporary directory on an environment defined by the implementation
// of `tsl::Env` and returns its path. Returns an InternalError status if
// failed.
absl::StatusOr<std::string> CreateTmpDir(tsl::Env* env);

#!/usr/bin/env bash
# Copyright 2023 The Go Authors. All rights reserved.
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.

case "$GOWASIRUNTIME" in
	"wasmedge")
		exec wasmedge --dir=/ --env PWD="$PWD" --env PATH="$PATH" ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
		;;
	"wasmer")
		exec wasmer run --dir=/ --env PWD="$PWD" --env PATH="$PATH" ${GOWASIRUNTIMEARGS:-} "$1" -- "${@:2}"
		;;
	"wazero")

      openldap:
        image: quay.io/minio/openldap
        ports:
          - "389:389"
          - "636:636"
        env:
          LDAP_ORGANIZATION: "MinIO Inc"
          LDAP_DOMAIN: "min.io"
          LDAP_ADMIN_PASSWORD: "admin"
      etcd:
        image: "quay.io/coreos/etcd:v3.5.1"
        env:
          ETCD_LISTEN_CLIENT_URLS: "http://0.0.0.0:2379"
          ETCD_ADVERTISE_CLIENT_URLS: "http://0.0.0.0:2379"
        ports: