this.includeGroups.addAll(Arrays.asList(includeGroups));
        return this;
    }

    public TestNGOptions excludeGroups(String... excludeGroups) {
        this.excludeGroups.addAll(Arrays.asList(excludeGroups));
        return this;
    }

    public TestNGOptions useDefaultListeners() {
        useDefaultListeners = true;
        return this;
    }

                ngIncluded = "database"
                ngExcluded = "slow"
            }
            test {
                useTestNG {
                    includeGroups ngIncluded
                    excludeGroups ngExcluded
                }
            }
        """.stripIndent()
        file('src/test/java/org/gradle/groups/SomeTest.java') << '''
            package org.gradle.groups;

        }
    }

    def "writes dependency with exclusion"() {
        def exclude1 = Mock(ExcludeRule) {
            getGroup() >> 'excludeGroup1'
            getModule() >> 'excludeModule1'
        }
        def exclude2 = Mock(ExcludeRule) {
            getGroup() >> 'excludeGroup2'
        }
        def exclude3 = Mock(ExcludeRule) {
            getModule() >> 'excludeModule3'
        }

        def fooMod = DefaultModuleIdentifier.newId('org', 'foo')
        def details = Mock(ArtifactResolutionDetails)

        given:
        descriptor.excludeGroup("g1")
        descriptor.excludeGroup("org")
        descriptor.excludeGroup("g2")

        when:
        def action = descriptor.toContentFilter()
        details.moduleId >> fooMod

        1 * repo2.content(_) >> { args ->
            args[0].execute(repo2Content)
        }
        1 * repo2Content.excludeGroup("foo")
        1 * repo3.content(_) >> { args ->
            args[0].execute(repo3Content)
        }
        1 * repo3Content.excludeGroup("foo")
        0 * _
    }

    def "can include group by regex exclusively"() {
        given:

        then:
        resolve.expectGraph {
            root(':', ':test:') {
                module('org:foo:1.0')
            }
        }

        where:
        notation << [
                "excludeGroup('org')",
                "excludeGroupByRegex('or.+')"
        ]
    }

    def "can include a module from a repository using #notation"() {
        def mod = ivyHttpRepo.module('org', 'foo', '1.0').publish()

        return desc -> config.execute(new InclusiveRepositoryContentDescriptor() {
            @Override
            public void includeGroup(String group) {
                desc.excludeGroup(group);
            }

            @Override
            public void includeGroupAndSubgroups(String groupPrefix) {
                desc.excludeGroupAndSubgroups(groupPrefix);
            }

    def setup() {
        using m2
        buildFile << """
                repositories {
                    mavenLocal {
                        content {
                            excludeGroup 'unused'
                        }
                    }
                }
                configurations { compile }
                dependencies {
                    compile 'group:projectA:1.2'

        }
        includeSpecs.add(new ContentSpec(matcherKind, group, moduleName, version, versionSelectorScheme, versionSelectors, true));
    }

    @Override
    public void excludeGroup(String group) {
        checkNotNull(group, "Group cannot be null");
        addExclude(group, null, null, MatcherKind.SIMPLE);
    }

    @Override
    public void excludeGroupAndSubgroups(String groupPrefix) {