predicate = predicate.or(dependency -> hasMatchingCoordinates(dependency, moduleSelector.getModule()));
        }

        Configuration classpathConfiguration = scriptHandler.getConfigurations().getByName(ScriptHandler.CLASSPATH_CONFIGURATION);
        return classpathConfiguration.getDependencies().stream().anyMatch(predicate);
    }

            xml.appendNode("ItemDefinitionGroup", [Condition: configCondition]).appendNode("ClCompile").appendNode("LanguageStandard", configuration.targetBinary.languageStandard.value)
        }
    }

    private Node getConfigurations() {
        return xml.ItemGroup.find({ it.'@Label' == 'ProjectConfigurations' }) as Node
    }

    private List<String> toPath(Set<File> files) {
        return files.collect({ toPath(it) })
    }

            ProjectState targetState = projectStateRegistry.stateFor(projectResult.projectIdentity);
            ConfigurationInternal targetConfig = (ConfigurationInternal) targetState.getMutableModel().getConfigurations().findByName(projectResult.targetConfiguration);
            if (targetConfig != null) {
                // Can be null when dependency metadata for target project has been loaded from cache

        configureDefaultDependencies(configuration);
    }

    @Override
    protected void configureTaskDefaults(Checkstyle task, final String baseName) {
        Configuration configuration = project.getConfigurations().getAt(getConfigurationName());
        configureTaskConventionMapping(configuration, task);
        configureReportsConventionMapping(task, baseName);
        configureToolchains(task);
    }

        configureDefaultDependencies(configuration);
    }

    @Override
    protected void configureTaskDefaults(CodeNarc task, String baseName) {
        Configuration configuration = project.getConfigurations().getAt(getConfigurationName());
        configureTaskConventionMapping(configuration, task);
        configureReportsConventionMapping(task, baseName);
        configureToolchains(task);
    }

    @Override

    @Input
    public Set<String> getHeaderFilePaths() {
        return collect(getHeaderFiles().getFiles(), File::getAbsolutePath);
    }

    @Nested
    public List<VisualStudioProjectConfiguration> getConfigurations() {
        if (configurations.isEmpty()) {
            return ImmutableList.of(new VisualStudioProjectConfiguration(this, "unbuildable", null));
        }
        return CollectionUtils.toList(configurations.values());

        this.descriptor.getGlobalExcludes().set(getComponent().map(ivyComponentParser::parseGlobalExcludes));
        this.descriptor.getConfigurations().set(this.configurations);
        this.descriptor.getArtifacts().set(providerFactory.provider(this::getArtifacts));
        this.descriptor.getDependencies().set(
            getComponent()

        project.getPluginManager().apply("jvm-ecosystem");
        project.getPluginManager().apply("jacoco");


        ConfigurationContainer configurations = ((ProjectInternal) project).getConfigurations();
        Configuration jacocoAggregation = configurations.dependencyScope(JACOCO_AGGREGATION_CONFIGURATION_NAME).get();

    @Override
    public void apply(Project project) {
        project.getPluginManager().apply("org.gradle.reporting-base");

        ConfigurationContainer configurations = ((ProjectInternal) project).getConfigurations();
        final Configuration testAggregation = configurations.dependencyScope(TEST_REPORT_AGGREGATION_CONFIGURATION_NAME).get();
        testAggregation.setDescription("A configuration to collect test execution results");

        );
    }

    private static Stream<? extends ConfigurationDetails> getConfigurationsWhichCouldHaveDependencyInfo(Project project) {
        return project.getConfigurations().stream()
            .map(ConfigurationInternal.class::cast)
            .filter(c -> c.isDeclarableByExtension())
            .map(ConfigurationDetails::of);
    }