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

)

func TestTokenFile(t *testing.T) {
	auth, err := newWithContents(t, `
token1,user1,uid1
token2,user2,uid2
token3,user3,uid3,"group1,group2"
token4,user4,uid4,"group2"
token5,user5,uid5,group5
token6,user6,uid6,group5,otherdata
token7,user7,uid7,"group1,group2",otherdata
`)
	if err != nil {
		t.Fatalf("unable to read tokenfile: %v", err)
	}

	testCases := []struct {
		Token string

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

        def task1 = task('task1', 'group1')
        def task2 = task('task2', 'group2')
        def task3 = task('task3', 'group1')

        when:
        def model = modelFor([task1, task2, task3])

        then:
        model.groups == ['group1', 'group2'] as Set
        model.getTasksForGroup('group1')*.path == [pathOf(task1), pathOf(task3)]
        model.getTasksForGroup('group2')*.path == [pathOf(task2)]
    }

	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
}

        model.build()

        then:
        model.groups == ([group] + groups - null) as Set

        where:
        group    | groups
        'group1' | []
        'group2' | []
        null     | ['group1']
        null     | ['group1', 'group2']
        'group1' | ['group2']
    }

    def "handles group which is not present in each project"() {

		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").

# See the License for the specific language governing permissions and
# limitations under the License.

# This scripts locates all API groups by their packages and versions
# Usage: `hack/verify-api-groups.sh`.

set -o errexit
set -o nounset
set -o pipefail

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
source "${KUBE_ROOT}/hack/lib/init.sh"

register_files=()