}

// Func contains Type fields specific to func types.
type Func struct {
	allParams []*Field // slice of all parameters, in receiver/params/results order

	startParams  int // index of the start of the (regular) parameters section
	startResults int // index of the start of the results section

	resultsTuple *Type // struct-like type representing multi-value results

)

// Tests isObjectDangling function
func TestIsObjectDangling(t *testing.T) {
	fi := newFileInfo("test-object", 2, 2)
	fi.Erasure.Index = 1

	ifi := newFileInfo("test-object", 2, 2)
	ifi.SetInlineData()
	ifi.Erasure.Index = 1

	testCases := []struct {
		name             string
		metaArr          []FileInfo
		errs             []error
		dataErrs         map[int][]int

			if i := bytes.Index(out, []byte(noPieWarning)); i >= 0 {
				// swallow -no_pie deprecation warning, issue 54482
				out = append(out[:i], out[i+len(noPieWarning):]...)
			}
		}
		if ctxt.IsDarwin() {
			const bindAtLoadWarning = "ld: warning: -bind_at_load is deprecated on macOS\n"
			if i := bytes.Index(out, []byte(bindAtLoadWarning)); i >= 0 {

				// The length of the expected ListObjectsResult.Objects
				// should match in both expected result from test cases
				// and in the output. On failure calling t.Fatalf,
				// otherwise it may lead to index out of range error in
				// assertion following this.
				if !testCase.versioned {
					if len(testCase.resultL.Objects) != len(resultL.Objects) {
						t.Logf("want: %v", objInfoNames(testCase.resultL.Objects))

	splitOffset int64
}

// lookup looks up a LocalSlot in the slot canonicalizer "sc", returning
// a canonical index for the slot, and adding it to the table if need
// be. Return value is the canonical slot index, and a boolean indicating
// whether the slot was found in the table already (TRUE => found).
func (sc *slotCanonicalizer) lookup(ls LocalSlot) (SlKeyIdx, bool) {
	split := noSlot

	if r0 != 0 {
		regerrno = Errno(r0)
	}
	return
}

func regEnumKeyEx(key Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, class *uint16, classLen *uint32, lastWriteTime *Filetime) (regerrno error) {

	serviceRegistry map[host.Name]*model.Service,
	mostSpecificWildcardVsIndex map[host.Name]types.NamespacedName,
) ([]string, []*model.Service) {
	// TODO: A further optimization would be to completely rely on the index and not do the loop below
	// However, that requires assuming that serviceRegistry never got filtered after the
	// egressListener was created.
	rule := virtualService.Spec.(*networking.VirtualService)

				t.Fatalf("%s: tree mismatch", test.name)
			}
		})
	}
}

func TestEscapeMap(t *testing.T) {
	data := map[string]string{
		"html":     `<h1>Hi!</h1>`,
		"urlquery": `http://www.foo.com/index.html?title=main`,
	}
	for _, test := range [...]struct {
		desc, input, output string
	}{
		// covering issue 20323
		{
			"field with predefined escaper name 1",
			`{{.html | print}}`,

representing a sub-field or item. The string will follow one of these four formats: 'f:<name>', where <name> is the name of a field in a struct, or key in a map 'v:<value>', where <value> is the exact json formatted value of a list item 'i:<index>', where <index> is position of a item in a list 'k:<keys>', where <keys> is a map of  a list item's key fields to their unique values If a key maps to an empty Fields value, the field that key represents is part of the set.\n\nThe exact format is defined...

	ws := ignore
	if mode&noIndent == 0 {
		ws = indent
	}

	// The first linebreak is always a formfeed since this section must not
	// depend on any previous formatting.
	prevBreak := -1 // index of last expression that was followed by a linebreak
	if prev.IsValid() && prev.Line < line && p.linebreak(line, 0, ws, true) > 0 {
		ws = ignore
		prevBreak = 0
	}