'groupB'          | 'artifactB'          | 'groupB'   | 'artifactB'
        'groupB'          | null                 | 'groupB'   | 'artifactA'
        null              | 'artifactB'          | 'groupA'   | 'artifactB'
    }

    def "can resolve module with relocated version"() {
        given:
        def moduleB = mavenHttpRepo.module('groupB', 'artifactB').publish()

        given:
        def requestedModule = mavenHttpRepo.module("groupA", "artifactA", "1.2").publish()
        requestedModule.pomFile.text = """
<project>
    <groupId>groupA</groupId>
    <artifactId>artifactA</artifactId>
    <version>1.2</version>
    <dependencies>
        <dependency>
            <groupId>groupB</groupId>
            <artifactId>artifactB</artifactId>
        </dependency>

        given:
        def original = mavenHttpRepo.module('groupA', 'artifactA', '1.0').publishPom()
        original.pomFile.text = """
<project>
    <groupId>groupA</groupId>
    <artifactId>artifactA</artifactId>
    <version>1.0</version>
    <distributionManagement>
        <relocation>
            <groupId>groupA</groupId>
            <artifactId>artifactA</artifactId>
            <version>2.0</version>

      <artifactId>providedRuntime-util</artifactId>
      <version>1.0</version>
      <type>war</type>
      <scope>provided</scope>
      <exclusions>
        <exclusion>
          <artifactId>*</artifactId>
          <groupId>*</groupId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>group6</groupId>
      <artifactId>testRuntime</artifactId>

        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>group6</groupId>
      <artifactId>testRuntime</artifactId>
      <version>1.0</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>group2</groupId>
      <artifactId>providedCompile</artifactId>
      <version>1.0</version>
      <scope>provided</scope>
      <exclusions>

    @Test public void another() {}
    @Test public void yetAnother() {}
}

public class ATestNGClassWithGroups {
    @Test(groups="group1") public void group1() {}
    @Test(groups="group2") public void group2() {}
    @Test(groups="group2,group3") public void excluded() {}
    @Test(groups="group4") public void ignored() {}
}

public class ATestNGFactoryClass {
    @Factory
    public Object[] suite() {

        failure.assertHasCause('Could not find :name3:1.0-SNAPSHOT.')
        failure.assertHasCause('Could not find group1::1.0.')
        failure.assertHasCause('Could not find any matches for group2::[1.0, 2.0] as no versions of group2: are available.')
        failure.assertHasCause('Could not find group3::1.0-SNAPSHOT.')
        failure.assertHasCause('Could not find group:name:.')
    }

  // sequence so are made dependent. For example, if `OpA` has parallel_ids
  //   `{group0:branch0, group1:branch0}`
  // and `OpB` has parallel_ids
  //   `{group0:branch0, group2:branch0}`
  // then `OpA` and `OpB` are executed in sequence because the common groups
  // have the same branch.
  //
  // If an op is not in `op_to_parallel_ids` then it is considered to have the

	return tgts, errs
}

// Split targets into two groups:
//
//	group1 contains all targets of type t
//	group2 contains the remaining targets
func splitTargets(targets []Target, t types.TargetType) (group1 []Target, group2 []Target) {
	for _, target := range targets {
		if target.Type() == t {
			group1 = append(group1, target)
		} else {
			group2 = append(group2, target)
		}
	}
	return
}

		serializer: serializer,
		group:      group,
	}
}

func (s *APIGroupHandler) WebService() *restful.WebService {
	mediaTypes, _ := negotiation.MediaTypesForSerializer(s.serializer)
	ws := new(restful.WebService)
	ws.Path(APIGroupPrefix + "/" + s.group.Name)
	ws.Doc("get information of a group")
	ws.Route(ws.GET("/").To(s.handle).
		Doc("get information of a group").
		Operation("getAPIGroup").