else
   return 1
  fi
}

function retry {
  local tmpFile
  tmpFile=$(mktemp)
  trap 'rm -f "${tmpFile}"' EXIT

  local failureRegex="$1"
  shift
  local n=1
  local max=5
  while true; do
    unset SHELL # Don't let environment control which shell to use
    if isatty; then
      if [ "$(uname)" == "Darwin" ]; then
        script -q -r "${tmpFile}" "${*}"
      else

	t.Helper()
	tmpfile, err := os.CreateTemp("", "")
	if err != nil {
		t.Fatal(err)
	}
	_, err = tmpfile.WriteString(content)
	if err != nil {
		t.Fatal(err)
	}
	err = tmpfile.Sync()
	if err != nil {
		t.Fatal(err)
	}
	_, err = tmpfile.Seek(0, 0)
	if err != nil {
		t.Fatal(err)
	}
	return tmpfile
}

func TestIsIstioConfigMap(t *testing.T) {

	buf := bytes.NewBuffer(make([]byte, 0, 7000000))
	genLargeBranch(buf)

	tmpfile := filepath.Join(dir, "x.s")
	if err := os.WriteFile(tmpfile, buf.Bytes(), 0644); err != nil {
		t.Fatalf("Failed to write file: %v", err)
	}

	// Assemble generated file.
	cmd := testenv.Command(t, testenv.GoToolPath(t), "tool", "asm", "-o", filepath.Join(dir, "x.o"), tmpfile)
	cmd.Env = append(os.Environ(), "GOARCH=riscv64", "GOOS=linux")

	gen(buf)

	tmpfile := filepath.Join(dir, "x.s")
	err = os.WriteFile(tmpfile, buf.Bytes(), 0644)
	if err != nil {
		t.Fatalf("can't write output: %v\n", err)
	}

	pattern := `0x0080\s00128\s\(.*\)\tMOVD\t\$3,\sR3`

	// assemble generated file
	cmd := testenv.Command(t, testenv.GoToolPath(t), "tool", "asm", "-S", "-o", filepath.Join(dir, "test.o"), tmpfile)
	cmd.Env = append(os.Environ(), "GOOS=linux")

	data, err := f.GetBytes()
	if err != nil {
		return "nobytes", err
	}
	tmpfile, err := os.CreateTemp("", "example")
	if err != nil {
		return "nofile", err
	}
	if _, err := tmpfile.Write(data); err != nil {
		return "nofile", err
	}
	if err := tmpfile.Close(); err != nil {
		return "nofile", err
	}
	return tmpfile.Name(), nil
}

// createRandomConfigFiles creates a slice of ReaderSources

#define TENSORFLOW_C_EXPERIMENTAL_FILESYSTEM_PLUGINS_GCS_GCS_HELPER_H_

#include <fstream>
#include <string>

class TempFile : public std::fstream {
 public:
  // We should specify openmode each time we call TempFile.
  TempFile(const std::string& temp_file_name, std::ios::openmode mode);
  TempFile(TempFile&& rhs);
  ~TempFile() override;
  const std::string getName() const;
  bool truncate();

 private:
  const std::string name_;
};

        File tmpFile = temporaryFileProvider.createTemporaryFile(jarFile.getName(), ".tmp");
        try {
            Files.createDirectories(parentDir.toPath());
            inPlaceBuilder.jar(tmpFile, action);
            Files.move(tmpFile.toPath(), jarFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
        } finally {
            Files.deleteIfExists(tmpFile.toPath());
        }
    }

	}

	for _, testCase := range testCases {
		testCase := testCase
		t.Run("", func(t *testing.T) {
			tmpfile, err := os.CreateTemp("", "testfile")
			if err != nil {
				t.Error(err)
			}
			tmpfile.WriteString(testCase.stat)
			tmpfile.Sync()
			tmpfile.Close()

			iostats, err := readDriveStats(tmpfile.Name())
			if err != nil && !testCase.expectErr {
				t.Fatalf("unexpected err; %v", err)
			}

    private final File tempFile;

    private final FileInputStream fileInputStream;

    public TemporaryFileInputStream(final File tempFile) throws FileNotFoundException {
        this.tempFile = tempFile;
        fileInputStream = new FileInputStream(tempFile);
    }

    public File getTemporaryFile() {
        return tempFile;
    }

    /*
     * (non-Javadoc)
     *

		err = os.RemoveAll(tmpdir)
		if err != nil {
			t.Fatalf("Fail to remove tmpdir: %v", err)
		}
	}()
	tmpfile, err := os.CreateTemp(tmpdir, "")
	if err != nil {
		t.Fatalf("Couldn't create tmpfile: %v", err)
	}
	if err := tmpfile.Close(); err != nil {
		t.Fatalf("Couldn't close tmpfile: %v", err)
	}

	tests := []struct {
		name     string
		filename string
		want     bool
	}{
		{