then:
        new JarTestFixture(war.archiveFile.get().asFile).assertContainsFile('WEB-INF/file.txt')
    }

    def "configures destinationDirectory for war tasks"() {
        when:
        project.pluginManager.apply(JavaBasePlugin)
        project.version = '1.0'

        then:
        def someWar = project.tasks.create('someWar', War)
        someWar.destinationDirectory.get().asFile == project.libsDirectory.get().asFile

package reconciler

import (
	"sync"
	"time"

	"k8s.io/apimachinery/pkg/util/wait"
	"k8s.io/klog/v2"
	"k8s.io/kubernetes/pkg/kubelet/pluginmanager/cache"
	"k8s.io/kubernetes/pkg/kubelet/pluginmanager/operationexecutor"
	"k8s.io/kubernetes/pkg/util/goroutinemap"
	"k8s.io/kubernetes/pkg/util/goroutinemap/exponentialbackoff"
)

	"k8s.io/apimachinery/pkg/util/wait"
	"k8s.io/client-go/tools/record"
	registerapi "k8s.io/kubelet/pkg/apis/pluginregistration/v1"
	"k8s.io/kubernetes/pkg/kubelet/pluginmanager/cache"
	"k8s.io/kubernetes/pkg/kubelet/pluginmanager/operationexecutor"
	"k8s.io/kubernetes/pkg/kubelet/pluginmanager/pluginwatcher"
)

const (
	// reconcilerLoopSleepDuration is the amount of time the reconciler loop
	// waits between successive executions

abstract class NativeToolChainPluginTest extends AbstractProjectBuilderSpec {

    def registry

    def setup() {
        registry = project.modelRegistry
        project.pluginManager.apply(getPluginClass())
    }

    abstract Class<? extends Plugin> getPluginClass()

    abstract Class<? extends NativeToolChain> getToolchainClass()

    String getToolchainName() {
        "toolchain"

import org.gradle.test.fixtures.AbstractProjectBuilderSpec

class JvmEcosystemPluginTest extends AbstractProjectBuilderSpec {

    def setup() {
        project.pluginManager.apply(JvmEcosystemPlugin)
    }

    def "configures the attributes schema"() {
        when:
        def attrs = project.dependencies.attributesSchema.attributes

        then:
        attrs.containsAll(

            initialRunner.run(target, services);

            PluginRequests initialPluginRequests = getInitialPluginRequests(initialRunner);

            PluginManagerInternal pluginManager = topLevelScript ? initialPassScriptTarget.getPluginManager() : null;
            PluginRequests autoAppliedPlugins = autoAppliedPluginHandler.getAutoAppliedPlugins(initialPluginRequests, target);

    final def project = TestUtil.create(testDir).rootProject();

    def "creates a test suite for each library under test"() {
        given:
        project.pluginManager.apply(CUnitConventionPlugin)
        project.model {
            components {
                main(NativeLibrarySpec)
            }
        }
        project.evaluate()

        when:

        buildScript """
            class Rules extends RuleSource {
              @Model
              String s1(Integer iDontExist) {
                "foo"
              }
            }

            pluginManager.apply Rules
        """

        then:
        fails "help"
        failureCauseContains("""
  Rules#s1(Integer)
    inputs:
      - <no path> Integer (parameter 1) [*]

	pluginManager := pluginmanager.NewPluginManager(
		filepath.Dir(pluginSocketName), /* sockDir */
		&record.FakeRecorder{},
	)

	runPluginManager(pluginManager)
	pluginManager.AddHandler(watcherapi.DevicePlugin, m.GetWatcherHandler())
	return pluginManager
}

func runPluginManager(pluginManager pluginmanager.PluginManager) {

        delegate.displayName

    override fun relativeProjectPath(path: String): String =
        delegate.relativeProjectPath(path)

    override fun getPluginManager(): PluginManager =
        delegate.pluginManager

    override fun setGroup(group: Any) {
        delegate.group = group
    }

    override fun fileTree(baseDir: Any): ConfigurableFileTree =
        delegate.fileTree(baseDir)