#define PREFIX HEADER_
            #define SUFFIX NAME
            #include HEADER(PREFIX, SUFFIX) // replaced with HEADER_(HEADER_, NAME) then HEADER_NAME then "hello.h"
        """

        expect:
        resolve() == [header]
    }

    def "can produce a macro function call by concatenating name and args passed as param"() {
        given:
        sourceFile << """

}

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) {

     * @throws IOException
     */
    protected static void loadConfigFile ( Path config, String[] applyMutations, Map<String, Map<String, String>> configs ) throws IOException {
        String fname = config.getFileName().toString();
        if ( !fname.endsWith(".conf") ) {
            return;
        }
        Properties props = new Properties();
        try ( FileChannel ch = FileChannel.open(config, StandardOpenOption.READ);

  }

  return CompileXla(client, computation, aot_opts, compile_result);
}

static Status ReadProtoFile(const string& fname, protobuf::Message* proto) {
  if (absl::EndsWith(fname, ".pbtxt")) {
    return ReadTextProto(Env::Default(), fname, proto);
  } else {
    return ReadBinaryProto(Env::Default(), fname, proto);
  }
}

static absl::once_flag targets_init;

static void InitializeTargets() {

        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) {

	if int(call.r1) != -1 {
		call.err = 0
	}
	return call.r1, call.err
}

//go:linkname syscall_gethostname
func syscall_gethostname() (name string, err uintptr) {
	cname := new([_MAXHOSTNAMELEN]byte)
	var args = [2]uintptr{uintptr(unsafe.Pointer(&cname[0])), _MAXHOSTNAMELEN}
	call := libcall{
		fn:   uintptr(unsafe.Pointer(&libc_gethostname)),
		n:    2,
		args: uintptr(unsafe.Pointer(&args[0])),
	}