private final Set<File> libConfigFiles;

    public WtpClasspathAttributeSupport(Project project, EclipseModel model) {
        isUtilityProject = !project.getPlugins().hasPlugin(WarPlugin.class) && !project.getPlugins().hasPlugin(EarPlugin.class);
        EclipseWtp eclipseWtp = model.getWtp();
        EclipseWtpComponent wtpComponent = eclipseWtp.getComponent();
        libDirName = wtpComponent.getLibDeployPath();

        codeCoverageResultsConf.extendsFrom(jacocoAggregation);
        codeCoverageResultsConf.setVisible(false);

        project.getPlugins().withType(JavaBasePlugin.class, plugin -> {
            // If the current project is jvm-based, aggregate dependent projects as jvm-based as well.

        DefaultObjectConfigurationAction action = createObjectConfigurationAction();
        ConfigureUtil.configureByMap(options, action);
        action.execute();
    }

    @Override
    public PluginContainer getPlugins() {
        return getPluginManager().getPluginContainer();
    }

    @Override
    @Inject
    public ConfigurationTargetIdentifier getConfigurationTargetIdentifier() {

        Model.Builder builder = Model.newBuilder(model);

        Build build = model.getBuild();
        if (build != null) {
            List<Plugin> plugins = build.getPlugins();
            Map<Object, Plugin> normalized = new LinkedHashMap<>(plugins.size() * 2);

            for (Plugin plugin : plugins) {
                Object key = plugin.getKey();

        Reporting reporting = model.getReporting();

        if (reporting != null) {
            for (ReportPlugin reportPlugin : reporting.getPlugins()) {
                XmlNode parentDom = reportPlugin.getDelegate().getConfiguration();

                if (parentDom != null) {
                    for (ReportSet execution : reportPlugin.getReportSets()) {

        if (type == null) {
            return Optional.empty();
        }
        return Optional.of(new DefaultPackaging(id, type, getPlugins(lifecycleMapping)));
    }

    private Map<String, PluginContainer> getPlugins(LifecycleMapping lifecycleMapping) {
        Map<String, PluginContainer> lfs = new HashMap<>();
        lifecycleMapping.getLifecycles().forEach((id, lifecycle) -> {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            oos.writeObject(model.getProperties());
            oos.writeObject(model.getBuild().getPlugins());
        }
    }

        project.getExtensions().add(ExtraModuleInfoPluginExtension.class, "extraJavaModuleInfo", extension);

        // setup the transform for all projects in the build
        project.getPlugins().withType(JavaPlugin.class).configureEach(javaPlugin -> configureTransform(project, extension));
    }

    private void configureTransform(Project project, ExtraModuleInfoPluginExtension extension) {

        addPluginMapping(goalPrefix, artifactId, artifactId);
    }

    public void addPluginMapping(String goalPrefix, String artifactId, String name) {
        List<Plugin> plugins = getMetadata().getPlugins();
        boolean found = false;
        for (Iterator<Plugin> i = plugins.iterator(); i.hasNext() && !found; ) {
            Plugin plugin = i.next();
            if (plugin.getPrefix().equals(goalPrefix)) {

        project = TestUtil.create(temporaryFolder).rootProject()
        project.pluginManager.apply(GroovyBasePlugin)
    }

    @Test void appliesTheJavaBasePluginToTheProject() {
        assertTrue(project.getPlugins().hasPlugin(JavaBasePlugin));
    }

    @Test void appliesMappingsToNewSourceSet() {
        def sourceSet = project.sourceSets.create('custom')