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

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

// 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]()

                @TaskAction
                void doIt() {
                    assert archiveFileName.get() == "something"
                }
            }

            task myTask(type: MyTask) {
                conventionMapping('archiveName') { 'not something' }
                archiveFileName.convention("something")
            }
        """

        expect: 'convention mapping is ignored'

            @Ignore
            @RunWith(org.gradle.CustomIgnoredTest.TheRunner.class)
            public class CustomIgnoredTest {
                static int count = 0;

                public boolean doSomething() {
                    return true;
                }

                public static class TheRunner extends Runner {
                    List descriptions = new ArrayList();

        versionCatalogFile.text == toPlatformLineSeparators("""$COMMON_START
[versions]
group-artifact-v5 = "1.1.1"
junit-something = "4"

[libraries]
group-artifact-v5 = { module = "group:artifact_5", version.ref = "group-artifact-v5" }
junit-something = { module = "JUnit:something", version.ref = "junit-something" }
""")
    }

    def "generates plugin"() {
        setup: