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'() {
        given:
        settingsFile << """

            includeGroup("my.company")
        }
    }
    mavenCentral {
        content {
            // this repository contains everything BUT artifacts with group starting with "my.company"
            excludeGroupByRegex("my\\.company.*")
        }
    }
}
// end::repository-filter[]

// tag::exclusive-repository-filter[]
repositories {
    // This repository will _not_ be searched for artifacts in my.company

            includeGroup "my.company"
        }
    }
    mavenCentral {
        content {
            // this repository contains everything BUT artifacts with group starting with "my.company"
            excludeGroupByRegex "my\\.company.*"
        }
    }
}
// end::repository-filter[]

// tag::exclusive-repository-filter[]
repositories {
    // This repository will _not_ be searched for artifacts in my.company

            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()

        given:
        repositories {

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

    def "can include module exclusively"() {
        given:

    /**
     * Declares that an entire group shouldn't be searched for in this repository.
     *
     * @param groupRegex the group name regular expression
     */
    void excludeGroupByRegex(String groupRegex);

    /**
     * Declares that an entire module shouldn't be searched for in this repository.
     *
     * @param group the group name
     * @param moduleName the module name
     */

                desc.excludeGroupAndSubgroups(groupPrefix);
            }

            @Override
            public void includeGroupByRegex(String groupRegex) {
                desc.excludeGroupByRegex(groupRegex);
            }

            @Override
            public void includeModule(String group, String moduleName) {
                desc.excludeModule(group, moduleName);
            }

        then:
        ex = thrown()
        ex.message == "Group cannot be null"
    }

    def "reasonable error message when input is incorrect (exclude regex)"() {
        when:
        descriptor.excludeGroupByRegex(null)

        then:
        IllegalArgumentException ex = thrown()
        ex.message == "Group regex cannot be null"

        when:
        descriptor.excludeModuleByRegex("foo", null)

        checkNotNull(groupPrefix, "Group prefix cannot be null");
        addExclude(groupPrefix, null, null, MatcherKind.SUB_GROUP);
    }

    @Override
    public void excludeGroupByRegex(String groupRegex) {
        checkNotNull(groupRegex, "Group regex cannot be null");
        addExclude(groupRegex, null, null, MatcherKind.REGEX);
    }

    @Override