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

                        assert files.collect { it.name } == ['b-bar.jar']
                    }
                }
            }
            project(':b') {
                configurations {
                    foo
                    bar
                    create 'default'
                }
                task barJar(type: Jar) {
                   archiveBaseName = 'b-bar'
                   destinationDirectory = buildDir

        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 {

        file('augmented').mkdir()
        file('augmented/a').mkdir()
        file('augmented/b').mkdir()
        file('augmented/b/b1').createFile()

        file('bar/foo').mkdir()
        file('bar/foo/c').mkdir()
        file('bar/foo/d').mkdir()
        file('bar/foo/d1').createFile()

        when:
        execute('showTransformedFiles')

        then:
        assertTransformExecuted()

        when:

[libraries]
simple = { group = "foo", name = "bar", version = "1.0" }
simple-with-rich1 = { group = "foo", name = "bar", version = { prefer = "1.0" } }
simple-with-rich2 = { group = "foo", name = "bar", version.prefer = "1.0" }
simple-with-rich3 = { group = "foo", name = "bar", version.require = "1.0" }
simple-with-rich4 = { group = "foo", name = "bar", version.strictly = "1.0" }
simple-with-rich5 = { group = "foo", name = "bar", version = { rejectAll = true } }

		{4, 5},
	},
}

var _ = map[string]T{
	"foo": {},
	"bar": {1, 2},
	"bal": {3, 4},
}

var _ = map[string]struct {
	x, y int
}{
	"foo": {},
	"bar": {1, 2},
	"bal": {3, 4},
}

var _ = map[string]interface{}{
	"foo": T{},
	"bar": T{1, 2},
	"bal": T{3, 4},
}

var _ = map[string][]int{
	"foo": {},
	"bar": {1, 2},
	"bal": {3, 4},
}

var _ = map[string][]int{

        group("foo")                                                        | module("bar")                               | anyOf(group("foo"), module("bar"))
        anyOf(group("foo"), group("bar"))                                   | group("foo")                                | groupSet("foo", "bar")

        when:
        succeeds "foo", "bar"

        then:
        output.contains "foo: foo"
        output.contains "bar: task bar: hi from bar"
    }

    def "can validate tasks using rule methods"() {
        given:
        buildFile << """
            class MyPlugin extends RuleSource {
                @Validate
                void checkTask(@Path('tasks.bar') EchoTask task) {