!pomReader.dependencyMgt.containsKey(new MavenDependencyKey('group-two', 'artifact-four', 'jar', null))
        assertResolvedPomDependencyManagement(new MavenDependencyKey('group-two', 'artifact-two', 'jar', null), 'version-three')
        assertResolvedPomDependency(new MavenDependencyKey('group-three', 'artifact-three', 'jar', null), 'version-three')

        nothing()                          | nothing()             | nothing()
        everything()                       | group("foo")          | group("foo")
        nothing()                          | group("foo")          | nothing()
        group("foo")                       | group("foo")          | group("foo")
        group("foo")                       | module("bar")         | moduleId("foo", "bar")

        if (matcher.matches()) {
            String uid = matcher.group(1) == null ? null : matcher.group(1).substring("uid=".length());
            String javaHome = matcher.group(2);
            JavaLanguageVersion javaVersion = JavaLanguageVersion.of(matcher.group(3));
            String daemonRegistryDir = matcher.group(4);
            String pidStr = matcher.group(5);
            Long pid = pidStr.equals("null") ? null : Long.parseLong(pidStr);

    static class ModuleAlignmentSpec {
        String group = 'org'
        String name
        List<String> seenVersions = []
        List<String> misses = []
        String alignsTo
        List<String> virtualPlatforms = []
        List<String> publishedPlatforms = []

        ModuleAlignmentSpec group(String group) {
            this.group = group
            this
        }

        gradleProject.tasks.findAll { it.name.startsWith('test') }.each {
            assert it.group == "task group ${it.name-'test'}"
        }
    }

    def "provide getGroup on Task using BuildInvocations"() {
        file("build.gradle") << '''
task test1(group:'task group 1')
task test2(group:'task group 2')
'''

        when:
        def buildInvocations = withConnection { ProjectConnection connection ->

		},
		{
			data:           []byte("{}"),
			defaultGVK:     &schema.GroupVersionKind{Kind: "Test", Group: "other", Version: "blah"},
			creater:        &mockCreater{obj: &testDecodable{}},
			expectedObject: &testDecodable{},
			expectedGVK:    &schema.GroupVersionKind{Kind: "Test", Group: "other", Version: "blah"},
			strict:         true,
		},

		// version without group is not defaulted

              "responseKind": {
                "group": "",
                "kind": "APIService",
                "version": ""
              },
              "scope": "Cluster",
              "singularResource": "apiservice",
              "subresources": [
                {
                  "responseKind": {
                    "group": "",
                    "kind": "APIService",

				{Group: "one", Version: "a", Kind: "first"},
				{Group: "two", Version: "b", Kind: "second"},
				{Group: "one", Version: "c", Kind: "third"},
			}},
			kindPatterns: []schema.GroupVersionKind{
				{Group: "one", Version: AnyVersion, Kind: AnyKind},
				{Group: AnyGroup, Version: "a", Kind: AnyKind},
			},
			result: schema.GroupVersionKind{Group: "one", Version: "a", Kind: "first"},
		},

    @Override
    protected Class<? extends Group> typeOfSelectedEntity() {
        return Group.class;
    }

    @Override
    protected Class<Group> typeOfHandlingEntity() {
        return Group.class;
    }

    @Override
    protected Class<GroupCB> typeOfHandlingConditionBean() {
        return GroupCB.class;
    }

    public ListResultBean<Group> selectList(CBCall<GroupCB> cbLambda) {

    private final String group;
    private final int hashCode;

    private DefaultGroupExclude(String group) {
        this.group = group;
        this.hashCode = group.hashCode();
    }

    static GroupExclude of(String group) {
        return new DefaultGroupExclude(group);
    }

    @Override
    public String getGroup() {
        return group;
    }

    @Override