apiVersion: v1
kind: Pod
metadata:
  # more than 63 characters
  name: helloworld-helloworld-helloworld-helloworld-helloworld-helloworld
spec:
  containers:
    - name: hello
      image: "fake.docker.io/google-samples/hello-go-gke:1.0"
      ports:
        - name: http

    }
  }
  function {
    signature {
      name: "foo5"
    }
  }
  function {
    signature {
      name: "foo6"
    }
  }
  function {
    signature {
      name: "foo7"
    }
  }
  function {
    signature {
      name: "foo8"
    }
  }
  function {
    signature {
      name: "foo9"
    }
  }
  function {
    signature {
      name: "foo10"
    }

}

func (r *Resolver) lookupCNAME(ctx context.Context, name string) (string, error) {
	order, conf := systemConf().hostLookupOrder(r, name)
	if order == hostLookupCgo {
		if cname, err, ok := cgoLookupCNAME(ctx, name); ok {
			return cname, err
		}
	}
	return r.goLookupCNAME(ctx, name, order, conf)
}

func (r *Resolver) lookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error) {

        value.capitalizedDisplayName == "F two three"
    }

    def "creates from type and name"() {
        expect:
        def value = Describables.withTypeAndName("some type", "name")
        value.displayName == "some type 'name'"
        value.toString() == "some type 'name'"
        value.capitalizedDisplayName == "Some type 'name'"
    }

    def "creates from description and value"() {
        expect:

	_, h := sh.GetScopeAndFqdn()
	vss := make([]*resource.Instance, 0)
	for sf, resources := range meshGatewayHosts {
		mghScope, mgh := sf.GetScopeAndFqdn()
		hName := host.Name(h)
		mghName := host.Name(mgh)
		if mghScope != util.ExportToAllNamespaces || !hName.Matches(mghName) {
			continue
		}
		vss = append(vss, resources...)
	}
	return vss
}

func combineResourceEntryNames(rList []*resource.Instance) string {

			name.CNIComponentName,
			name.IngressComponentName,
			name.EgressComponentName,
		},
		name.IstioBaseComponentName: {
			name.PilotComponentName,
		},
		name.CNIComponentName: {
			name.ZtunnelComponentName,
		},
	}

	// InstallTree is a top down hierarchy tree of dependencies where children must wait for the parent to complete
	// before starting installation.
	InstallTree = make(ComponentTree)
)

func libresolv_res_9_nsearch_trampoline()

func ResNsearch(state *ResState, dname *byte, class, typ int, ans *byte, anslen int) (int, error) {
	r1, _, errno := syscall_syscall6(abi.FuncPCABI0(libresolv_res_9_nsearch_trampoline),
		uintptr(unsafe.Pointer(state)),
		uintptr(unsafe.Pointer(dname)),
		uintptr(class),
		uintptr(typ),
		uintptr(unsafe.Pointer(ans)),
		uintptr(anslen))
	if errno != 0 {

	if a.SkipServiceCheck {
		return
	}
	for name, whs := range webhooks {
		for _, wh := range whs {
			if wh.ClientConfig.Service == nil {
				// it is an url, skip it
				continue
			}
			fname := resource.NewFullName(
				resource.Namespace(wh.ClientConfig.Service.Namespace),
				resource.LocalName(wh.ClientConfig.Service.Name))
			if !context.Exists(gvk.Service, fname) {

		fmt.Sprintf("%s-%s-%s-%4d%02d%02d-%d.log", prog, progVers, goVers, year, month, day, os.Getpid()),
		" ", "")
	fname := filepath.Join(debugDir, logBase)
	if _, err := os.Stat(fname); err == nil {
		// This process previously called upload.Run
		return nil, nil
	}
	f, err := os.OpenFile(fname, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0666)
	if err != nil {
		if os.IsExist(err) {

	}

	if len(mgArgs.Components) != 0 {
		filteredManifests := name.ManifestMap{}
		for _, cArg := range mgArgs.Components {
			componentName := name.ComponentName(cArg)
			if cManifests, ok := manifests[componentName]; ok {
				filteredManifests[componentName] = cManifests
			} else {
				return fmt.Errorf("incorrect component name: %s. Valid options: %v", cArg, name.AllComponentNames)
			}
		}
		manifests = filteredManifests