features:  []string{"A", "C"},
			required:  []string{"A", "B", "C"},
			exception: []string{"B"},
			ok:        true,
			out:       "",
		},

		// Test that a feature required on a subset of ports is implicitly satisfied
		// by the same feature being implemented on all ports. That is, it shouldn't
		// say "pkg syscall (darwin-amd64), type RawSockaddrInet6 struct" is missing.
		// See https://go.dev/issue/4303.

func TestS390XOperandParser(t *testing.T) {
	parser := newParser("s390x")
	testOperandParser(t, parser, s390xOperandTests)
}

func TestFuncAddress(t *testing.T) {
	type subtest struct {
		arch  string
		tests []operandTest
	}
	for _, sub := range []subtest{
		{"amd64", amd64OperandTests},
		{"386", x86OperandTests},
		{"arm", armOperandTests},
		{"arm64", arm64OperandTests},
		{"ppc64", ppc64OperandTests},

	Example:
	//go:cgo_ldflag "-lpthread"
	//go:cgo_ldflag "-L/usr/local/sqlite3/lib"

A package compiled with cgo will include directives for both
internal and external linking; the linker will select the appropriate
subset for the chosen linking mode.

Example

As a simple example, consider a package that uses cgo to call C.sin.
The following code will be generated by cgo:

	// compiled by gc

	//go:cgo_ldflag "-lm"

	SUBSD X11, X11                          // f2450f5cdb
	SUBSS (BX), X2                          // f30f5c13
	SUBSS (R11), X2                         // f3410f5c13
	SUBSS X2, X2                            // f30f5cd2
	SUBSS X11, X2                           // f3410f5cd3
	SUBSS (BX), X11                         // f3440f5c1b
	SUBSS (R11), X11                        // f3450f5c1b
	SUBSS X2, X11                           // f3440f5cda

<code>S2</code>, regardless of what other methods
<code>S1</code> and <code>S2</code> may have or share.
</p>

<p>
A type implements any interface comprising any subset of its methods
and may therefore implement several distinct interfaces. For
instance, all types implement the <i>empty interface</i>:
</p>

<pre>
interface{}
</pre>

<p>

pkg bytes, func Title //deprecated
pkg crypto/tls, method (*Conn) NetConn() net.Conn
pkg crypto/tls, type Config struct, PreferServerCipherSuites //deprecated
pkg crypto/x509, method (*CertPool) Subjects //deprecated
pkg debug/buildinfo, func Read(io.ReaderAt) (*debug.BuildInfo, error)
pkg debug/buildinfo, func ReadFile(string) (*debug.BuildInfo, error)
pkg debug/buildinfo, type BuildInfo = debug.BuildInfo

pkg crypto/x509, func ParsePKIXPublicKey([]uint8) (interface{}, error)
pkg crypto/x509, method (*CertPool) AddCert(*Certificate)
pkg crypto/x509, method (*CertPool) AppendCertsFromPEM([]uint8) bool
pkg crypto/x509, method (*CertPool) Subjects() [][]uint8
pkg crypto/x509, method (*Certificate) CheckCRLSignature(*pkix.CertificateList) error
pkg crypto/x509, method (*Certificate) CheckSignature(SignatureAlgorithm, []uint8, []uint8) error

	{[]byte(dots + dots + dots), " ", false},
}

func TestContainsAny(t *testing.T) {
	for _, ct := range ContainsAnyTests {
		if ContainsAny(ct.b, ct.substr) != ct.expected {
			t.Errorf("ContainsAny(%s, %s) = %v, want %v",
				ct.b, ct.substr, !ct.expected, ct.expected)
		}
	}
}

var ContainsRuneTests = []struct {
	b        []byte
	r        rune
	expected bool
}{

	corresponding method types unify exactly,
	and the method set of one of the interfaces is a subset of
	the method set of the other interface.
</li>
<li>
	Only one type is an interface (but not a type parameter),
	corresponding methods of the two types unify per the element matching mode,
	and the method set of the interface is a subset of
	the method set of the other type.
</li>
<li>

		r, size := utf8.DecodeRuneInString(s[i:])
		i += size
		// Officially, ZIP uses CP-437, but many readers use the system's
		// local character encoding. Most encoding are compatible with a large
		// subset of CP-437, which itself is ASCII-like.
		//
		// Forbid 0x7e and 0x5c since EUC-KR and Shift-JIS replace those
		// characters with localized currency and overline characters.
		if r < 0x20 || r > 0x7d || r == 0x5c {