case *Basic:
		return typ // nothing to do
	case *TypeParam:
		return smap.lookup(t)
	}

	// general case
	subst := subster{
		pos:       pos,
		smap:      smap,
		check:     check,
		expanding: expanding,
		ctxt:      ctxt,
	}
	return subst.typ(typ)
}

type subster struct {
	pos       syntax.Pos
	smap      substMap
	check     *Checker // nil if called via Instantiate

	case *Basic:
		return typ // nothing to do
	case *TypeParam:
		return smap.lookup(t)
	}

	// general case
	subst := subster{
		pos:       pos,
		smap:      smap,
		check:     check,
		expanding: expanding,
		ctxt:      ctxt,
	}
	return subst.typ(typ)
}

type subster struct {
	pos       token.Pos
	smap      substMap
	check     *Checker // nil if called via Instantiate

        when:
        def lister = repository.createResolver().providedVersionLister

        then:
        lister.rules.configurableRules[0].ruleClass == CustomVersionLister
        lister.rules.configurableRules[0].ruleParams.isolate() == [] as Object[]
    }

    def "can inject configuration into a custom version lister"() {
        repository.name = 'name'

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			lister := UnstructuredToVal(tc.unstructured, tc.schema).(traits.Lister)
			if lister.Size().Value() != tc.size {
				t.Errorf("Expected Size to return %d but got %d", tc.size, lister.Size().Value())
			}
			iter := lister.Iterator()
			for i := 0; i < int(tc.size); i++ {
				get := lister.Get(types.Int(i)).Value()
				if !reflect.DeepEqual(get, tc.unstructured[i]) {

                expectResolve()
            }
        }

        then:
        succeeds 'checkDeps'
    }

    void "caches version listing using #lister lister"() {
        ListerInteractions listerInteractions
        switch (lister) {
            case 'simple':
                listerInteractions = withLister(modules, true)
                break;
            default:

				return false, fmt.Errorf("timed out waiting for cache sync of param informer")
			}

			var lister cache.GenericNamespaceLister = informer.Lister()
			if scope == meta.RESTScopeNamespace {
				lister = informer.Lister().ByNamespace(objectMeta.GetNamespace())
			}

			fetched, err := lister.Get(objectMeta.GetName())
			if err != nil {
				if errors.IsNotFound(err) {
					return false, nil
				}

// NewHistory returns an instance of Interface that uses client to communicate with the API Server and lister to list
// ControllerRevisions. This method should be used to create an Interface for all scenarios other than testing.
func NewHistory(client clientset.Interface, lister appslisters.ControllerRevisionLister) Interface {
	return &realHistory{client, lister}
}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			lister := UnstructuredToVal(tc.unstructured, tc.schema).(traits.Lister)
			if lister.Size().Value() != tc.size {
				t.Errorf("Expected Size to return %d but got %d", tc.size, lister.Size().Value())
			}
			iter := lister.Iterator()
			for i := 0; i < int(tc.size); i++ {
				get := lister.Get(types.Int(i)).Value()
				if !reflect.DeepEqual(get, tc.unstructured[i]) {

// InformerForResourceFunc knows how to provision an informer
type InformerForResourceFunc func(schema.GroupVersionResource) (informers.GenericInformer, error)

// ListerFuncForResourceFunc knows how to provision a lister from an informer func.
// The lister returns errors until the informer has synced.
func ListerFuncForResourceFunc(f InformerForResourceFunc) quota.ListerForResourceFunc {
	return func(gvr schema.GroupVersionResource) (cache.GenericLister, error) {

		kubeClient:  kubeClient,
		pvcLister:   pvcInformer.Lister(),
		pvcsSynced:  pvcInformer.Informer().HasSynced,
		pvLister:    pvInformer.Lister(),
		pvsSynced:   pvInformer.Informer().HasSynced,
		podLister:   podInformer.Lister(),
		podsSynced:  podInformer.Informer().HasSynced,
		podIndexer:  podInformer.Informer().GetIndexer(),
		nodeLister:  nodeInformer.Lister(),
		nodesSynced: nodeInformer.Informer().HasSynced,