func() (string, error) { return "createdBy", nil },
			map[string]string{
				GCPProject:       "env_pid",
				GCPProjectNumber: "env_pn",
				GCPCluster:       "env_cluster",
				GCPLocation:      "env_location",
			},
			map[string]string{
				GCPProject: "env_pid", GCPProjectNumber: "env_pn", GCPLocation: "env_location", GCPCluster: "env_cluster",
			},
		},
		{
			"use env variable without fill",

			uintptr(unsafe.Pointer(&argvp[0])),
			uintptr(unsafe.Pointer(&envvp[0])))
	} else if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
		// Similarly on Darwin.
		err1 = execveDarwin(argv0p, &argvp[0], &envvp[0])
	} else if runtime.GOOS == "openbsd" && runtime.GOARCH != "mips64" {
		// Similarly on OpenBSD.
		err1 = execveOpenBSD(argv0p, &argvp[0], &envvp[0])
	} else {
		_, _, err1 = RawSyscall(SYS_EXECVE,

			}
		}
	}
}

func Environ() []string {
	envp, e := GetEnvironmentStrings()
	if e != nil {
		return nil
	}
	defer FreeEnvironmentStrings(envp)

	r := make([]string, 0, 50) // Empty with room to grow.
	const size = unsafe.Sizeof(*envp)
	for *envp != 0 { // environment block ends with empty string
		// find NUL terminator
		end := unsafe.Pointer(envp)
		for *(*uint16)(end) != 0 {
			end = unsafe.Add(end, size)

# Test go generate provides the right "$GOPACKAGE" name in an x_test
go generate './generate/env_test.go'
stdout 'main_test'

# Test go generate provides the right "$PWD"
go generate './generate/env_pwd.go'
stdout $WORK'[/\\]gopath[/\\]src[/\\]generate'

-- echo.go --
package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {
	fmt.Println(strings.Join(os.Args[1:], " "))
	fmt.Println()

 protected:
  SaveVariablesToCheckpointTest() : env_(Env::Default()) {
    ctx_.loadDialect<mlir::func::FuncDialect, mlir::TF::TensorFlowDialect,
                     mlir::tf_saved_model::TensorFlowSavedModelDialect>();
  }

  absl::StatusOr<std::string> MakeTempDir() {
    std::string tmp_dir{};
    if (!env_->LocalTempFilename(&tmp_dir)) {
      return absl::InternalError("Failed to create temp file.");

  status = env_->NewWritableFile(filepath, &new_file);
  if (!status.ok())
    GTEST_SKIP() << "NewWritableFile() not supported: " << status;

  status = env_->DeleteFile(filepath);
  EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}

TEST_P(ModularFileSystemTest, TestDeleteFileDoesNotExist) {
  const std::string filepath = GetURIForPath("a_file");
  Status status = env_->DeleteFile(filepath);

 public:
  LowerClusterToRuntimeOpsTest() {
    mlir::RegisterCommonToolingDialects(registry_);
    context_.appendDialectRegistry(registry_);
    context_.loadAllAvailableDialects();

    env_ = Env::Default();
    test_group_name_ = "TestGroup";
    test_dir_ = testing::TmpDir();
    setenv("TF_DUMP_GRAPH_PREFIX", test_dir_.c_str(), /*overwrite=*/1);
  }

                public Process exec(String command, String[] envp) { return null; }
                public Process exec(String command, String[] envp, File file) { return null; }
                public Process exec(String command, List<?> envp, File file) { return null; }
                public Process exec(String[] command) { return null; }
                public Process exec(String[] command, String[] envp) { return null; }

        externalProcessStarted(command, consumer);
        return runtime.exec(command, envp);
    }

    public static Process exec(Runtime runtime, String[] command, String[] envp, String consumer) throws IOException {
        externalProcessStarted(command, consumer);
        return runtime.exec(command, envp);
    }

    // Delete files in the test directory.
    std::vector<std::string> files;
    TF_ASSERT_OK(
        env_->GetMatchingPaths(tsl::io::JoinPath(test_dir_, "*"), &files));
    for (const std::string& file : files) {
      TF_ASSERT_OK(env_->DeleteFile(file));
    }
  }

  tsl::Env* env_;
  std::string test_dir_;
  std::unique_ptr<mlir::MLIRContext> ctx_;
};