def exclude1 = Mock(ExcludeRule) {
            getGroup() >> 'excludeGroup1'
            getModule() >> 'excludeModule1'
        }
        def exclude2 = Mock(ExcludeRule) {
            getGroup() >> 'excludeGroup2'
        }
        def exclude3 = Mock(ExcludeRule) {
            getModule() >> 'excludeModule3'
        }

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

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

        then:
        ex = thrown()
        ex.message == "Module name cannot be null"

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

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

        when:

        1 * repo1.content(_) >> { args ->
            args[0].execute(repo1Content)
        }
        1 * repo1Content.excludeModule("com.mycompany", "core")
        1 * repo3.content(_) >> { args ->
            args[0].execute(repo3Content)
        }
        1 * repo3Content.excludeModule("com.mycompany","core")
        0 * _
    }

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

    /**
     * Declares that an entire module shouldn't be searched for in this repository.
     *
     * @param group the group name
     * @param moduleName the module name
     */
    void excludeModule(String group, String moduleName);

    /**
     * Declares that an entire module shouldn't be searched for in this repository, using regular expressions.
     *
     * @param groupRegex the group name regular expression

                desc.excludeGroupByRegex(groupRegex);
            }

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

            @Override
            public void includeModuleByRegex(String groupRegex, String moduleNameRegex) {

            root(':', ':test:') {
                module('org:foo:1.0')
                module('org:bar:1.0')
            }
        }

        where:
        notation << [
                "excludeModule('org', 'foo')",
                "excludeModuleByRegex('or.+', 'f[o]{1,2}')"
        ]
    }

    def "can include a specific module using #notation"() {

        checkNotNull(groupRegex, "Group regex cannot be null");
        addExclude(groupRegex, null, null, MatcherKind.REGEX);
    }

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