Map<String, ModuleIdentifier> byName = groupIdToModules.get(group);
        if (byName == null) {
            byName = groupIdToModules.computeIfAbsent(group, k -> new ConcurrentHashMap<>());
        }
        ModuleIdentifier moduleIdentifier = byName.get(name);
        if (moduleIdentifier == null) {
            moduleIdentifier = DefaultModuleIdentifier.newId(group, name);
            byName.put(name, moduleIdentifier);
        }

Original: mY_nAmE

			}
			cert, err := ParseCertificate(certDER)
			if err != nil {
				t.Fatalf("ParseCertificate failed: %s", err)
			}

			var opts VerifyOptions
			if tc.dnsName != "" {
				opts.DNSName = tc.dnsName
			}
			if !tc.time.IsZero() {
				opts.CurrentTime = tc.time
			}
			if len(tc.eku) > 0 {
				opts.KeyUsages = tc.eku
			}

			expectedErr := tc.expectedErr

    private SortPolicy sortPolicy;
    public PBXGroup(String name, @Nullable String path, SourceTree sourceTree) {
        super(name, path, sourceTree);

        sortPolicy = SortPolicy.BY_NAME;
        children = new ArrayList<>();

        childGroupsByName = CacheBuilder.newBuilder().build(
            new CacheLoader<String, PBXGroup>() {
                @Override

		return nil, "", ptyError("grantpt", err)
	}
	if err := unix.Unlockpt(m); err != nil {
		syscall.Close(m)
		return nil, "", ptyError("unlockpt", err)
	}
	processTTY, err = unix.Ptsname(m)
	if err != nil {
		syscall.Close(m)
		return nil, "", ptyError("ptsname", err)
	}
	return os.NewFile(uintptr(m), "pty"), processTTY, nil

	case CertificateSigningRequest:
		return "CertificateSigningRequest"
	case ConfigMap:
		return "ConfigMap"
	case CustomResourceDefinition:
		return "CustomResourceDefinition"
	case DNSName:
		return "DNSName"
	case DaemonSet:
		return "DaemonSet"
	case Deployment:
		return "Deployment"
	case DestinationRule:
		return "DestinationRule"
	case EndpointSlice:
		return "EndpointSlice"
	case Endpoints:

type symNameFn func(s loader.Sym) string

// ErrorReporter is used to make error reporting thread safe.
type ErrorReporter struct {
	loader.ErrorReporter
	unresSyms  map[unresolvedSymKey]bool
	unresMutex sync.Mutex
	SymName    symNameFn
}

// errorUnresolved prints unresolved symbol error for rs that is referenced from s.
func (reporter *ErrorReporter) errorUnresolved(ldr *loader.Loader, s, rs loader.Sym) {
	reporter.unresMutex.Lock()

		kind.Secret,
		kind.ProxyConfig,
		kind.DNSName,
	),
	model.SidecarProxy: sets.New(
		kind.Gateway,
		kind.WorkloadGroup,
		kind.WorkloadEntry,
		kind.Secret,
		kind.ProxyConfig,
		kind.DNSName,

		kind.KubernetesGateway,
	),
	model.Waypoint: sets.New(
		kind.Gateway,
		kind.WorkloadGroup,
		kind.WorkloadEntry,
		kind.Secret,
		kind.ProxyConfig,
		kind.DNSName,

		kind.KubernetesGateway,
	),
}

	if efw == nil {
		return result
	}
	hasName := sets.New(names...)
	for _, p := range efw.Patches[networking.EnvoyFilter_EXTENSION_CONFIG] {
		if p.Operation != networking.EnvoyFilter_Patch_ADD {
			continue
		}
		ec, ok := p.Value.(*core.TypedExtensionConfig)
		if !ok {
			log.Errorf("extension config patch %+v does not match TypeExtensionConfig type", p.Value)
			continue
		}
		if hasName.Contains(ec.GetName()) {

tasks.register("upper") {
    doLast {
        val someString = "mY_nAmE"
        println("Original: $someString")
        println("Upper case: ${someString.toUpperCase()}")
    }