#include "tensorflow/core/framework/op_gen_lib.h"
#include "tensorflow/core/platform/env.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/path.h"
#include "tsl/platform/status.h"

namespace tensorflow {
namespace generator {

Controller::Controller(PathConfig path_config, Env* env)
    : env_(env), path_config_(path_config) {
  // Load the Op and API definitions
  InitializeOpApi();

            Map<String, String> env2 = getWindowsEnv();
            env2.remove(name);
        }
    }

    public void setenv(String name, String value) {
        Map<String, String> map = getEnv();
        map.put(name, value);
        if (OperatingSystem.current().isWindows()) {
            Map<String, String> env2 = getWindowsEnv();
            env2.put(name, value);
        }
    }

    /**

	// Write new environment variables.
	if envv != nil {
		for i = 0; i < len(envv); i++ {
			r1, _, _ = RawSyscall(SYS_CREATE, uintptr(unsafe.Pointer(envv[i].name)), uintptr(O_WRONLY), uintptr(0666))

			if int32(r1) == -1 {
				goto childerror
			}

			envfd = int(r1)

			r1, _, _ = RawSyscall6(SYS_PWRITE, uintptr(envfd), uintptr(unsafe.Pointer(envv[i].value)), uintptr(envv[i].nvalue),
				^uintptr(0), ^uintptr(0), 0)

  }

  DialectRegistry registry_;
  MLIRContext context_;
  OwningOpRef<mlir::ModuleOp> mlir_module_;
  Env* env_;
  std::string test_dir_;
  std::string test_group_name_;
};

TEST_F(LoggingHooksTest, DumpsPassData) {
  std::vector<std::string> files;
  TF_ASSERT_OK(env_->GetChildren(test_dir_, &files));
  EXPECT_THAT(files, ::testing::IsEmpty());

  TF_ASSERT_OK(CreateMlirModule("dead_const.mlir"));

    // 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_;
};

import (
	"bytes"
	"fmt"
	"internal/goexperiment"
	"log"
	"os"
	"reflect"
	"strings"
)

func main() {
	// Delete existing experiment constant files.
	ents, err := os.ReadDir(".")
	if err != nil {
		log.Fatal(err)
	}
	for _, ent := range ents {
		name := ent.Name()
		if !strings.HasPrefix(name, "exp_") {
			continue
		}
		// Check that this is definitely a generated file.
		data, err := os.ReadFile(name)

  const std::vector<Flag> tmp = {
      {"graph", &flags->graph,
       "Input GraphDef file.  If the file ends in '.pbtxt' it is expected to "
       "be in the human-readable proto text format, otherwise it is expected "
       "to be in the proto binary format."},
      {"debug_info", &flags->debug_info,
       "Graph debug info file.  If the file ends in '.pbtxt' it is expected to "
       "be in the human-readable proto text format, otherwise it is expected "

		}
	}
	return false, nil
}

var valRe = regexp.MustCompile(`^\[\]byte\(([^)]+)\)$`)

func main() {
	dir, expected := os.Args[1], os.Args[2]
	ents, err := os.ReadDir(dir)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	for _, ent := range ents {
		name := filepath.Join(dir, ent.Name())
		if good, err := checkFile(name, expected); err != nil {
			fmt.Fprintln(os.Stderr, err)
			os.Exit(1)

package net

import (
	"reflect"
	"strings"
	"testing"
)

type staticHostEntry struct {
	in  string
	out []string
}

var lookupStaticHostTests = []struct {
	name string
	ents []staticHostEntry
}{
	{
		"testdata/hosts",
		[]staticHostEntry{
			{"odin", []string{"127.0.0.2", "127.0.0.3", "::2"}},
			{"thor", []string{"127.1.1.1"}},
			{"ullr", []string{"127.1.1.2"}},

 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);
  }