return "", err
	}
	return o.mapper.ResourceSingularizer(resource)
}

func (o *lazyObject) Reset() {
	o.lock.Lock()
	defer o.lock.Unlock()
	if o.loaded && o.err == nil {
		MaybeResetRESTMapper(o.mapper)
	}

	if len(allMappings) == 0 {
		return nil, &NoKindMatchError{GroupKind: gk, SearchedVersions: versions}
	}
	return allMappings, nil
}

func (m MultiRESTMapper) Reset() {
	for _, t := range m {
		MaybeResetRESTMapper(t)
	}

	return m.Delegate.KindsFor(partiallySpecifiedResource)
}

func (m PriorityRESTMapper) Reset() {
	MaybeResetRESTMapper(m.Delegate)

		return nil, &NoResourceMatchError{PartialResource: schema.GroupVersionResource{Group: gk.Group, Resource: gk.Kind}}
	}
	return mappings, nil
}

// MaybeResetRESTMapper calls Reset() on the mapper if it is a ResettableRESTMapper.
func MaybeResetRESTMapper(mapper RESTMapper) {
	m, ok := mapper.(ResettableRESTMapper)
	if ok {
		m.Reset()
	}

	err error
}

func (l *errorRestMapper) RESTMapping(gk schema.GroupKind, versions ...string) (*meta.RESTMapping, error) {
	return nil, l.err
}

func (l *errorRestMapper) Reset() {
	meta.MaybeResetRESTMapper(l.RESTMapper)
}

func newDefaultBuilderWithMapperError(fakeClientFn FakeClientFunc, err error) *Builder {
	return NewFakeBuilder(
		fakeClientFn,
		func() (meta.RESTMapper, error) {

	c "k8s.io/kubernetes/pkg/controller"
	"k8s.io/kubernetes/test/utils/ktesting"
)

type testRESTMapper struct {
	meta.RESTMapper
}

func (m *testRESTMapper) Reset() {
	meta.MaybeResetRESTMapper(m.RESTMapper)
}

func TestGarbageCollectorConstruction(t *testing.T) {
	config := &restclient.Config{}
	tweakableRM := meta.NewDefaultRESTMapper(nil)