buf := bytes.NewBuffer(make([]byte, 0, genBufSize))
	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=loong64", "GOOS=linux")

		{"string", `"test"`, "panic: test"}} {

		b := bytes.Buffer{}
		fmt.Fprintf(&b, fn, tc.Type, tc.Input)

		err = ioutil.WriteFile(tmpFile, b.Bytes(), 0644)
		if err != nil {
			log.Fatal(err)
		}

		cmd := exec.Command("go", "run", tmpFile)
		var buf bytes.Buffer
		cmd.Stdout = &buf
		cmd.Stderr = &buf
		cmd.Env = os.Environ()
		cmd.Run() // ignore err as we expect a panic

        setup:
        def tempFile = temporaryFolder.createFile("optionFile")
        def optionsMap = createOptionsMap()
        when:
        _ * optionfile.options >> optionsMap
        _ * optionfile.getSourceNames() >> new OptionLessStringsJavadocOptionFileOption([]);
        javadocOptionFileWriter.write(tempFile)
        then:
        tempFile.text == toPlatformLineSeparators("""-key1 'value1'
-key2 'value2'

		}
	}
}

func TestOffsetWriter_Seek(t *testing.T) {
	tmpfilename := "TestOffsetWriter_Seek"
	tmpfile, err := os.CreateTemp(t.TempDir(), tmpfilename)
	if err != nil || tmpfile == nil {
		t.Fatalf("CreateTemp(%s) failed: %v", tmpfilename, err)
	}
	defer tmpfile.Close()
	w := NewOffsetWriter(tmpfile, 0)

	// Should throw error errWhence if whence is not valid
	t.Run("errWhence", func(t *testing.T) {

	f, err := os.CreateTemp("", "")
	if err != nil {
		t.Errorf("Error creating tmp file: %v", err)
	}
	tmpFile := f.Name()
	f.Close()
	defer os.Remove(f.Name())
	fi1, err := os.Stat(tmpFile)
	if err != nil {
		t.Fatalf("Error Stat(): %v", err)
	}
	fi2, err := os.Stat(tmpFile)
	if err != nil {
		t.Fatalf("Error Stat(): %v", err)
	}
	if !SameFile(fi1, fi2) {

		t.Fatal(err)
	}
	defer os.RemoveAll(tmpdir)
	tmpfile, err := os.Create(filepath.Join(tmpdir, "input.s"))
	if err != nil {
		t.Fatal(err)
	}
	defer tmpfile.Close()
	_, err = tmpfile.WriteString(s)
	if err != nil {
		t.Fatal(err)
	}
	cmd := testenv.Command(t,
		testenv.GoToolPath(t), "tool", "asm", "-S", "-dynlink",
		"-o", filepath.Join(tmpdir, "output.6"), tmpfile.Name())

	cmd.Env = append(os.Environ(),

                final File tempFile = ComponentUtil.getSystemHelper().createTempFile("esreq_", ".json");
                try (final InputStream in = response.getContentAsStream()) {
                    CopyUtil.copy(in, tempFile);
                } catch (final Exception e1) {
                    if (tempFile != null && tempFile.exists() && !tempFile.delete()) {

}

// RemoveAll removes any temporary files associated with a [Form].
func (f *Form) RemoveAll() error {
	var err error
	for _, fhs := range f.File {
		for _, fh := range fhs {
			if fh.tmpfile != "" {
				e := os.Remove(fh.tmpfile)
				if e != nil && !errors.Is(e, os.ErrNotExist) && err == nil {
					err = e
				}
			}
		}
	}
	return err
}

// A FileHeader describes a file part of a multipart request.

    }
    fontsize="32"
    label = "Application Cluster";
    style=filled
    color=deepskyblue

  }
  
  edge[weight=5]
  appfiles[label="application/*"]
  app -> appfiles [constraint=false]
  appfiles -> appcontents
  appfiles -> appwp
  appfiles -> ig
  appfiles -> nwc
  ztunchart[label="ztunnel",class="helm"]
  ztunnel -> ztunchart -> ztunnelds
  istiodchart[label="istiod",class="helm"]
  cpt -> istiodchart

    @Test
    void testEquals() throws Exception {
        File tempFile = createTempFile("pomTest");
        FileModelSource instance = new FileModelSource(tempFile);

        assertFalse(instance.equals(null));
        assertFalse(instance.equals(new Object()));
        assertTrue(instance.equals(instance));
        assertTrue(instance.equals(new FileModelSource(tempFile)));
    }

    @Test