new DefaultPluginId("foo.bar").qualified
    }

    def "qualify if unqualified"() {
        expect:
        new DefaultPluginId("foo").withNamespace("bar").toString() == "bar.foo"
    }

    def "throws exception when trying to add multiple namespaces"() {
        when:
        new DefaultPluginId("foo.bar").withNamespace("bar")
        then:
        thrown IllegalArgumentException
    }

		{"foo", "/", false},
		{"foo", "foo", true},
		{"foo", "foo/", false},
		{"foo", "/foo", false},
		{"foo/bar", "", true},
		{"foo/bar", "foo", true},
		{"foo/bar", "foo/", true},
		{"foo/bar", "/foo", false},
		{"foo/bar", "foo/bar", true},
		{"foo/bar", "foo/bar/", false},
		{"foo/bar", "/foo/bar", false},
	} {
		got := HasPathPrefix(tt.s, tt.prefix)
		if got != tt.want {

			in: []string{
				"bar",
				"bar.ns",
				"bar.ns.svc",
				"bar.ns.svc.cluster.local",
				"foo:80",
				"foo.ns:81",
				"foo.ns.svc:82",
				"foo.ns.svc.cluster.local:83",
			},
			want: listenerNames{
				"bar":        {RequestedNames: sets.New("bar")},
				"bar.ns":     {RequestedNames: sets.New("bar.ns")},
				"bar.ns.svc": {RequestedNames: sets.New("bar.ns.svc")},

  "foo.someop"() ({
    "bar.a"(%arg0) : (f32) -> f32
    "bar.b"(%arg1) : (f32) -> f32
    "bar.c"(%0) : (f32) -> f32
  }, {}): () -> ()
  return
}

// CHECK: func @handles_regions_that_use_arguments
// CHECK: call [[foo:@[^(]*]](%arg0, %arg1, %0)
// CHECK: func [[bar:@[^(]*]]
// CHECK-SAME: dialect = "bar"
// CHECK: bar.a
// CHECK: bar.b
// CHECK: bar.c
// CHECK: func [[foo]]

		},
		{
			"non-wildcard domain",
			"bar.com", "foo.com", false,
		},
		{
			"non-wildcard domain - order doesn't matter",
			"foo.com", "bar.com", false,
		},

		{
			"domain does not match subdomain",
			"bar.foo.com", "foo.com", false,
		},
		{
			"domain does not match subdomain - order doesn't matter",
			"foo.com", "bar.foo.com", false,
		},

		{
			"wildcard matches subdomains",

# Note, this program does not run. Presumably, 'DWORD $0' is simpler to
# assembly 2^26 or so times.
#
# We build something which should be laid out as such:
#
# bar.Bar
# main.Func1
# bar.Bar+400-tramp0
# main.BigAsm
# main.Func2
# bar.Bar+400-tramp1
#
# bar.Bar needs to be placed far enough away to generate relocations
# from main package calls. and main.Func1 and main.Func2 are placed

- `workload-bar-[cert|key].pem`: workload certificate and key for URI SAN `spiffe://trust-domain-bar/ns/bar/sa/bar` signed by `ca-cert.key`.
- `workload-foo-root-certs.pem`: root and intermediate CA certificates for foo workload certificate.
- `workload-bar-root-certs.pem`: root and intermediate CA certificates for bar workload certificate.

            200,
            {"items": [{"item_name": "Bar"}, {"item_name": "Baz"}], "q": "foo"},
        ),
        (
            "/items?q=bar&limit=2",
            200,
            {"items": [{"item_name": "Foo"}, {"item_name": "Bar"}], "q": "bar"},
        ),
        (
            "/items?q=bar&skip=1&limit=1",
            200,
            {"items": [{"item_name": "Bar"}], "q": "bar"},
        ),
        (

// license that can be found in the LICENSE file.

package main

type Foo[T any] interface {
	CreateBar() Bar[T]
}

type Bar[T any] func() Bar[T]

func (f Bar[T]) CreateBar() Bar[T] {
	return f
}

func abc[R any]() {
	var _ Foo[R] = Bar[R](nil)()
}

func main() {
	abc[int]()

        buildB = new BuildTestFile(repo.workTree, "B")
        buildB.createDirs("foo", "bar")
        // git doesn't track directories so we need to create files in them
        buildB.file("foo/.gitkeepdir").touch()
        buildB.file("bar/.gitkeepdir").touch()
        buildB.settingsFile << """
            rootProject.name = 'B'
            include 'foo', 'bar'
        """
        buildB.buildFile << """
            allprojects {