// In addition, to support lookup by IP address, they will have *alias* names for each IP the resource represents.
// There may be multiple aliases for the same resource (examples: service in multiple networks, or a dual-stack workload).
// Aliases are keyed by network/IP address. Example: "default/1.2.3.4".
//

			meshConfig: &meshconfig.MeshConfig{
				TrustDomain: "cluster.local",
				TrustDomainAliases: []string{
					"alias-1.domain", "alias-1.domain", "some-other-alias-1.domain", "alias-2.domain", "alias-2.domain",
				},
			},
			want: []string{"cluster.local", "alias-1.domain", "some-other-alias-1.domain", "alias-2.domain"},
		},
		{
			name: "Mixed duplicated trust domains in mesh config",
			meshConfig: &meshconfig.MeshConfig{

		var alias []byte
		hdr := (*unsafeheader.Slice)(unsafe.Pointer(&alias))
		hdr.Data = unsafe.Pointer(&s[0])
		hdr.Cap = cap(s)
		hdr.Len = len(s)

		if !bytes.Equal(alias, s) {
			t.Errorf("alias of %T(%q) constructed via Slice = %T(%q)", s, s, alias, alias)
		}
		if cap(alias) != cap(s) {
			t.Errorf("alias of %T with cap %d has cap %d", s, cap(s), cap(alias))
		}
	})

        LibraryEntry l = new LibraryEntry();
        if (RESERVED_LIBRARY_PREFIX.matcher(alias).find()) {
            alias = "my" + alias;
        }
        l.alias = findFreeAlias(libraries.keySet(), alias);
        l.module = module;
        l.version = versionEntry.version;
        l.versionRef = versionEntry.alias;
        libraries.put(l.alias, l);
        return l;
    }

        return keys.containsKey(alias) || certChains.containsKey(alias);
    }

    @Override
    public int engineSize() {
        return keys.size() + certChains.size();
    }

    @Override
    public boolean engineIsKeyEntry(String alias) {
        return keys.containsKey(alias);
    }

    @Override
    public boolean engineIsCertificateEntry(String alias) {

                           "\n");
      }
    }
  }

  if (!aliases.empty()) {
    strings::StrAppend(&comment, "\nAliases:\n");
    for (const auto& alias : aliases) {
      strings::StrAppend(&comment, "* ", alias, "\n");
    }
  }
  comment = MakeComment(comment, "");
}

string OpInfo::GetOpAttrStruct() const {
  string struct_fields;

	AVUPLF
	AVMSLG
	AVMSLEG
	AVMSLOG
	AVMSLEOG

	ANOPH // NOP

	// binary
	ABYTE
	AWORD
	ADWORD

	// Breakpoint
	ABRRK

	// end marker
	ALAST

	// aliases
	ABR = obj.AJMP
	ABL = obj.ACALL

        String normalizedAlias = normalize(alias);
        if (config.hasDependency(normalizedAlias)) {
            return Optional.of(dependencyFactory.create(normalizedAlias));
        }
        return Optional.empty();
    }

    @Override
    public final Optional<Provider<ExternalModuleDependencyBundle>> findBundle(String alias) {
        String normalizedBundle = normalize(alias);

// A generic type alias may be used like any other generic type.
type A[P any] = RHS[P, int]

func _(a A[string]) {
	a.p = "foo"
	a.q = 42
}

// A generic alias may refer to another generic alias.
type B[P any] = A[P]

func _(a B[string]) {
	a.p = "foo"
	a.q = 42
	// error messages print the instantiated alias type

		t.Errorf("Talias1 print:\nhave: %s\nwant: %s", out, want)
	}

	t2 := Talias2{Tint: 1, Tint2: 2}
	out = fmt.Sprintf("%#v", t2)
	want = "reflectlite_test.Talias2{Tint:1, Tint2:2}"
	if out != want {
		t.Errorf("Talias2 print:\nhave: %s\nwant: %s", out, want)
	}