{
			name:          "resolves from port name",
			portName:      "http-something",
			expectedProto: protocol.HTTP,
		},
		{
			name:          "prefers appProto over portName",
			portName:      "http-something",
			appProto:      &https,
			expectedProto: protocol.HTTPS,
		},
		{
			name:          "resolves from appProto",
			portName:      "something-httpx",
			appProto:      &https,
			expectedProto: protocol.HTTPS,
		},

        then: 0 * _
    }

    class Base {
        @Incubating
        Object doSomething() { null }
    }

    interface Iface {}

    class Child extends Base implements Serializable, Iface {
        @Nullable
        Object doSomething() { null }
    }

    def "walking type hierarchy happens breadth-first"() {
        def visitor = Mock(Types.TypeVisitor)

        !step.matches("")
        !step.matches("something else")
    }

    def "matches name case insensitive"() {
        def step = new FixedPatternStep("name", false)

        expect:
        step.matches("name")
        step.matches("Name")
        step.matches("NAME")
        !step.matches("")
        !step.matches("something else")
    }

			req:    newCSR(kubeletServerPEMOptions, pemOptions{uris: []string{"http://something"}}),
			usages: kubeletServerUsages,
			exp:    false,
		},
		"does not default to kubelet-serving if it specifies an emailAddress SAN": {
			req:    newCSR(kubeletServerPEMOptions, pemOptions{emailAddresses: []string{"something"}}),
			usages: kubeletServerUsages,
			exp:    false,
		},
	}
	for name, test := range tests {

		handles.Inc()
		return nil
	}))
	q.Add(types.NamespacedName{Name: "something"})
	stop := make(chan struct{})
	go q.Run(stop)
	retry.UntilOrFail(t, q.HasSynced, retry.Delay(time.Microsecond))
	assert.Equal(t, handles.Load(), 1)
	q.Add(types.NamespacedName{Name: "something else"})
	close(stop)
	assert.NoError(t, q.WaitForClose(time.Second))
	// event 2 is guaranteed to happen from WaitForClose

					"test": "label",
				},
			},
		},
	}

	wantJSON := `
		{
      "host":"something.svc.local",
      "trafficPolicy": {
        "loadBalancer":{"simple":"UNSPECIFIED"}
       },
       "subsets": [
         {"name":"foo","labels":{"test":"label"}}
       ]
		}`

	wantYAML := `host: something.svc.local
subsets:
- labels:
    test: label
  name: foo
trafficPolicy:
  loadBalancer:

        !step.matches(".a")
        !step.matches(".ab")
        !step.matches(".b")
        !step.matches(".bcd")
        !step.matches("_abc")
        !step.matches("")
        !step.matches("something else")
    }

    def "matches name case insensitive"() {
        def step = new HasPrefixPatternStep(".abc", false)

        expect:
        step.matches(".abc")
        step.matches(".ABC")

            import org.gradle.api.DefaultTask
            import org.gradle.api.tasks.TaskAction

            class HelloWorld1 extends DefaultTask {
                @TaskAction
                void doSomething() {
                    println 'Hello world! (buildSrc)'
                }
            }
        """

        buildFile << plugin.useDeclaration << """

    @Unroll("detects changes to class referenced through a #modifier field")
    def "detects changes to class referenced through a field"() {
        given:
        source """class A {
    $modifier B b;
    void doSomething() {
        Runnable r = b;
        r.run();
    }
}"""
        source '''abstract class B implements Runnable { }'''

        outputs.snapshot { run language.compileTaskName }

        when:

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"./a"
)

func main() {
	a.DoSomething[byte]()