if (excludes == null || excludes.isEmpty()) {
            return Collections.emptyList();
        }
        return Arrays.stream(excludes.split(","))
                .map(String::trim)
                .filter(s -> !s.isEmpty())
                .collect(Collectors.toList());
    }

                }
            }
            if (targetNodes.isEmpty()) {
                // There is a chance we could not attach target configurations previously
                List<EdgeState> unattachedDependencies = targetComponent.getModule().getUnattachedDependencies();
                if (!unattachedDependencies.isEmpty()) {
                    for (EdgeState otherEdge : unattachedDependencies) {

            repositoryHandler.add(new PluginArtifactRepository(repository));
        }
        if (repositoryHandler.isEmpty()) {
            repositoryHandler.gradlePluginPortal();
        }
    }

    @Override
    public PluginResolver getPluginResolver() {

        final List<DependencyVerificationConfiguration.TrustedKey> keys = configuration.getTrustedKeys();
        if (keys.isEmpty()) {
            return;
        }
        writer.startElement(TRUSTED_KEYS);
        Map<String, List<DependencyVerificationConfiguration.TrustedKey>> groupedByKeyId = keys
            .stream()

        @Override
        public void call(SourceUnit source) {
            if (!source.getAST().getMethods().isEmpty()) {
                hasMethods = true;
            }
            emptyScript = isEmpty(source);
        }

        private boolean isEmpty(SourceUnit source) {
            List<Statement> statements = source.getAST().getStatementBlock().getStatements();

    public int getColumnNumber() {
        return columnNumber;
    }

    @Override
    public String getLocation() {
        StringBuilder buffer = new StringBuilder(256);

        if (!getSource().isEmpty()) {
            if (buffer.length() > 0) {
                buffer.append(", ");
            }
            buffer.append(getSource());
        }

        if (getLineNumber() > 0) {

        }
    }

    private static boolean isNotEmpty(TestFilterSpec filter) {
        return !filter.getIncludedTests().isEmpty()
            || !filter.getIncludedTestsCommandLine().isEmpty()
            || !filter.getExcludedTests().isEmpty();
    }

    private static class ClassMethodNameFilter implements PostDiscoveryFilter {
        private final TestSelectionMatcher matcher;

     */
    public boolean isEmpty() {
        return (includes == null || includes.isEmpty())
            && (excludes == null || excludes.isEmpty())
            && (includeSpecs == null || includeSpecs.isEmpty())
            && (excludeSpecs == null || excludeSpecs.isEmpty());
    }

    public Spec<FileTreeElement> getAsSpec() {

        Set<Object> mutableValues = getMutableValues();
        if (mutableValues.isEmpty() && immutableValues.isEmpty()) {
            return;
        }
        final Deque<Object> queue = new ArrayDeque<Object>(mutableValues.size() + immutableValues.size());
        queue.addAll(immutableValues);
        queue.addAll(mutableValues);
        while (!queue.isEmpty()) {
            Object dependency = queue.removeFirst();

        descriptor.setVersion("0.1");
        List<String> errors = new ArrayList<>();
        mavenPluginValidator.validate(plugin, descriptor, errors);
        assertTrue(errors.isEmpty());
    }

    @Test
    void testInvalidGroupId() {
        Artifact plugin = new DefaultArtifact(
                "org.apache.maven.its.plugins",
                "maven-it-plugin",
                "0.1",