def defaultMatcher = new DefaultVersionSelectorScheme(new DefaultVersionComparator(), new VersionParser())
    def mapper = new MavenVersionSelectorScheme(defaultMatcher)

    def "translates to maven syntax"() {
        given:
        def selector = defaultMatcher.parseSelector(input)

        expect:
        mapper.renderSelector(selector) == output

        where:
        input                | output

    boolean isEnabled(BuildEventSubscriptions subscriptions);

    Class<DETAILS> getDetailsType();

    /**
     * Returns the trackers that are used by this mapper. If this mapper is enabled, then the trackers should be notified of
     * build operation execution. If this mapper is not enabled, the trackers can be ignored.
     */
    default List<? extends BuildOperationTracker> getTrackers() {
        return Collections.emptyList();
    }

	for _, tc := range testcases {
		t.Run(tc.Name, func(t *testing.T) {
			mapper := NewEquivalentResourceRegistryWithIdentity(tc.IdentityFunc)

			// register
			for _, data := range kindsToRegister {
				mapper.RegisterKindFor(data.gvr, data.subresource, data.gvk)
			}
			// verify
			for _, data := range kindsToRegister {
				if kind := mapper.KindFor(data.gvr, data.subresource); kind != data.gvk {

        private final List<T> delegate;
        private final Function<T, Q> mapper;

        WrappingList(List<T> delegate, Function<T, Q> mapper) {
            this.delegate = delegate;
            this.mapper = mapper;
        }

        @Override
        public Q get(int index) {
            return mapper.apply(delegate.get(index));
        }

        @Override
        public int size() {

package main

import (
	"./a"
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	got := a.Mapper([]int{1, 2, 3}, strconv.Itoa)
	want := []string{"1", "2", "3"}
	if !reflect.DeepEqual(got, want) {
		panic(fmt.Sprintf("got %s, want %s", got, want))
	}

	fgot := a.Mapper([]float64{2.5, 2.3, 3.5}, func(f float64) string {
		return strconv.FormatFloat(f, 'f', -1, 64)
	})

	type result struct {
		proto int
		err   error
	}
	ch := make(chan result) // unbuffered
	go func() {
		if err := acquireThread(ctx); err != nil {
			ch <- result{err: mapErr(err)}
			return
		}
		defer releaseThread()
		runtime.LockOSThread()
		defer runtime.UnlockOSThread()
		proto, err := getprotobyname(name)
		select {
		case ch <- result{proto: proto, err: err}:

		discoveryClient, err := out.discoveryClient.Get()
		if err != nil {
			return nil, err
		}
		mapper, err := out.mapper.Get()
		if err != nil {
			return nil, err
		}
		return restmapper.NewShortcutExpander(mapper, discoveryClient, func(string) {}), nil
	})
	return out
}

func (c *clientFactory) ToRESTConfig() (*rest.Config, error) {

	visitor Visitor
	typer   runtime.ObjectTyper
	mapper  *mapper
}

// NewFlattenListVisitor creates a visitor that will expand list style runtime.Objects
// into individual items and then visit them individually.
func NewFlattenListVisitor(v Visitor, typer runtime.ObjectTyper, mapper *mapper) Visitor {
	return FlattenListVisitor{v, typer, mapper}
}

func (v FlattenListVisitor) Visit(fn VisitorFunc) error {

	kubeClient      clientset.Interface
	mapper          meta.ResettableRESTMapper
}

func NewResourceVersionController(
	ctx context.Context,
	kubeClient clientset.Interface,
	discoveryClient *discovery.DiscoveryClient,
	metadataClient metadata.Interface,
	svmInformer svminformers.StorageVersionMigrationInformer,
	mapper meta.ResettableRESTMapper,
) *ResourceVersionController {

        List<TestFailure> failures = new ArrayList<TestFailure>();

        List<Throwable> innerExceptions = invokeMethod(throwable, "getErrors", List.class);
        for (Throwable innerException : innerExceptions) {
            failures.add(mapper.createFailure(innerException));
        }

        return failures;
    }