}

    /**
     * @param methodName Method name
     * @param excludes Signature equivalences to exclude from the returned index
     * @return Overloaded candidate methods named {@literal methodName} indexed by signature equivalence except thoses
     * matching any of the signature equivalence provided in {@literal excludes} or {@literal null} if none
     */

                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>**/HistoryConfigurationTest.java</exclude>
                        <exclude>**/TestDataFactory.java</exclude>
                    </excludes>
                    <forkMode>once</forkMode>
                    <reportFormat>xml</reportFormat>
                </configuration>

        !spec.isSatisfiedBy(element("a/c/d.java"))
        !spec.isSatisfiedBy(element("a/c/d/e.groovy"))

        // Default excludes
        !spec.isSatisfiedBy(element("/.git/refs"))
    }

    def "creates spec for exclude patterns"() {
        def source = new PatternSet()
        source.exclude("a/b/**", "**/c/d/*.java")

        expect:
        def spec = factory.createSpec(source)

    }

    @Override
    public PatternFilterable exclude(Iterable<String> excludes) {
        patterns.exclude(excludes);
        return this;
    }

    @Override
    public PatternFilterable exclude(String... excludes) {
        patterns.exclude(excludes);
        return this;
    }

    @Override
    public PatternFilterable exclude(Spec<FileTreeElement> excludeSpec) {

    }

    protected void writeMavenExcludeRules(Encoder encoder, List<ExcludeMetadata> excludes) throws IOException {
        encoder.writeSmallInt(excludes.size());
        for (ExcludeMetadata exclude : excludes) {
            encoder.writeString(exclude.getModuleId().getGroup());
            encoder.writeString(exclude.getModuleId().getName());
        }
    }

    public List<String> getExcludes() {
        return excludes;
    }

    public void setExcludes(@Nullable List<String> excludes) {
        this.excludes = excludes;
    }

    /**
     * List of classloader names that should be excluded from analysis. Names can use wildcards (* and ?). Defaults to an empty list.
     */
    @Nullable
    @Optional
    @Input
    public List<String> getExcludeClassLoaders() {

        this.strictVersion = strictVersion
        this.rejects = rejects?:Collections.<String>emptyList()
        if (excludes) {
            exclusions = excludes.collect { Map exclusion ->
                String group = exclusion.get('group')?.toString()
                String module = exclusion.get('module')?.toString()
                new ExcludeSpec(group, module)
            }
        }

 */
package org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.simple;

import com.google.common.base.Objects;
import com.google.common.collect.ImmutableSet;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.CompositeExclude;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ExcludeSpec;

import java.util.Set;

 * limitations under the License.
 */
package org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.simple;

import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ModuleSetExclude;
import org.gradle.internal.component.model.IvyArtifactName;

import java.util.Set;

  <build>
    <plugins>
      <plugin>
        <artifactId>maven-surefire-plugin</artifactId>
        <configuration>
          <excludes>
            <exclude>org/codehaus/plexus/util/FileBasedTestCase.java</exclude>
            <exclude>**/Test*.java</exclude>
          </excludes>
        </configuration>
      </plugin>
    </plugins>
  </build>
  <distributionManagement>
    <status>deployed</status>