<groupId>excludeGroup</groupId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>group3</groupId>
      <artifactId>runtime</artifactId>
      <version>1.0</version>
      <scope>runtime</scope>
      <exclusions>
        <exclusion>
          <artifactId>excludeArtifact2</artifactId>
          <groupId>excludeGroup2</groupId>
        </exclusion>

          <groupId>excludeGroup</groupId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>group3</groupId>
      <artifactId>runtime</artifactId>
      <version>1.0</version>
      <scope>runtime</scope>
      <exclusions>
        <exclusion>
          <artifactId>excludeArtifact2</artifactId>
          <groupId>excludeGroup2</groupId>
        </exclusion>

        }
    }

    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'
        }

        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;
    }

                        useTestNG()
                        targets.all {
                            testTask.configure {
                                options {
                                    excludeGroups "exclude"
                                }
                            }
                        }
                    }
                }
            }
        """
        writeSources(file("src/test/java"))

        testngOptions.includeGroups(groups)

        then:
        testngOptions.includeGroups == groups as Set
        testngOptions.excludeGroups.empty
    }

    def testExcludeGroups() {
        when:
        testngOptions.excludeGroups(groups)

        then:
        testngOptions.excludeGroups == groups as Set
        testngOptions.includeGroups.empty
    }

    def copyFromOverridesOldOptions() {
        given:

        run 'buildEnvironment'

        then:
        outputContains("org:foo:1.0")

        where:
        inSettings  | notation
        true        | "excludeGroup('org')"
        true        | "excludeGroupByRegex('or.+')"
        false       | "excludeGroup('org')"
        false       | "excludeGroupByRegex('or.+')"
    }

    def 'exclusive content filtering in settings prevents adding repositories in project'() {

        this.useDefaultListener = useDefaultListener;
        this.threadPoolFactoryClass = threadPoolFactoryClass;
        this.includeGroups = includeGroups;
        this.excludeGroups = excludeGroups;
        this.listeners = listeners;
        this.configFailurePolicy = configFailurePolicy;
        this.preserveOrder = preserveOrder;
        this.groupByInstances = groupByInstances;

}

dependencies {
    testImplementation("org.testng:testng:6.3.1")
}

// tag::test-config[]
tasks.named<Test>("test") {
    useTestNG {
        val options = this as TestNGOptions
        options.excludeGroups("integrationTests")
        options.includeGroups("unitTests")
    }
}

        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