f := Fopen("main.go", "r")
	if f.Swigcptr() == 0 {
		fatal("fopen failed")
	}
	if Fgetc(f) != '/' || Fgetc(f) != '/' || Fgetc(f) != ' ' || Fgetc(f) != 'C' {
		fatal("read unexpected characters")
	}
	if Fclose(f) != 0 {
		fatal("fclose failed")
	}

	println("OK")
}

func fatal(f string, args ...any) {
	fmt.Fprintln(os.Stderr, fmt.Sprintf(f, args...))
	os.Exit(1)

//
// Example:
//   void func() {
//     FILE* fp = fopen("data.txt", "r");
//     if (fp == nullptr) return;
//     auto fp_cleaner = gtl::MakeCleanup([fp] { fclose(fp); });
//     // No matter what, fclose(fp) will happen.
//     DataObject d;
//     while (ReadDataObject(fp, &d)) {
//       if (d.IsBad()) {
//         LOG(ERROR) << "Bad Data";
//         return;
//       }

%typemap(in) const char * %{
	$1 = malloc($input.n + 1);
	memcpy($1, $input.p, $input.n);
	$1[$input.n] = '\0';
%}
%typemap(freearg) const char * %{
	free($1);
%}

FILE *fopen(const char *name, const char *mode);
int fclose(FILE *);

	"io"

	xioutil "github.com/minio/minio/internal/ioutil"
)

// DrainBody close non nil response with any response Body.
// convenient wrapper to drain any remaining data on response body.
//
// Subsequently this allows golang http RoundTripper
// to reuse the same connection for future requests.
func DrainBody(respBody io.ReadCloser) {
	// Callers should close resp.Body when done reading from it.

                super.connect(snk)
                write(TextUtil.toPlatformLineSeparators("abc\n123\nclose\nmore-stuff").bytes)
            }
        })
        run "echo"

        then:
        output.contains("[abc][123]")
    }

			if len(srcs) > 0 && srcs[0] == '[' {
				bclose := bytealg.IndexByteString(srcs, ']')
				if bclose == -1 {
					conf.err = errors.New("unclosed criterion bracket")
					return conf
				}
				var err error
				criteria, err = parseCriteria(srcs[1:bclose])
				if err != nil {
					conf.err = errors.New("invalid criteria: " + srcs[1:bclose])
					return conf
				}
				srcs = srcs[bclose+1:]
			}

	cmd.Stderr = &outbuf

	rp, wp, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}
	defer rp.Close()

	cmd.ExtraFiles = []*os.File{wp}

	if err := cmd.Start(); err != nil {
		wp.Close()
		t.Fatalf("starting program: %v", err)
	}

	if err := wp.Close(); err != nil {
		t.Logf("closing write pipe: %v", err)
	}
	if _, err := rp.Read(make([]byte, 1)); err != nil {

	okforlen   [types.NTYPE]bool
	okforarith [types.NTYPE]bool
)

var builtinFuncs = [...]struct {
	name string
	op   ir.Op
}{
	{"append", ir.OAPPEND},
	{"cap", ir.OCAP},
	{"clear", ir.OCLEAR},
	{"close", ir.OCLOSE},
	{"complex", ir.OCOMPLEX},
	{"copy", ir.OCOPY},
	{"delete", ir.ODELETE},
	{"imag", ir.OIMAG},
	{"len", ir.OLEN},
	{"make", ir.OMAKE},
	{"max", ir.OMAX},
	{"min", ir.OMIN},
	{"new", ir.ONEW},

	name     string
	nargs    int
	variadic bool
	kind     exprKind
}{
	_Append:  {"append", 1, true, expression},
	_Cap:     {"cap", 1, false, expression},
	_Clear:   {"clear", 1, false, statement},
	_Close:   {"close", 1, false, statement},
	_Complex: {"complex", 2, false, expression},
	_Copy:    {"copy", 2, false, statement},
	_Delete:  {"delete", 2, false, statement},
	_Imag:    {"imag", 1, false, expression},

	name     string
	nargs    int
	variadic bool
	kind     exprKind
}{
	_Append:  {"append", 1, true, expression},
	_Cap:     {"cap", 1, false, expression},
	_Clear:   {"clear", 1, false, statement},
	_Close:   {"close", 1, false, statement},
	_Complex: {"complex", 2, false, expression},
	_Copy:    {"copy", 2, false, statement},
	_Delete:  {"delete", 2, false, statement},
	_Imag:    {"imag", 1, false, expression},