typeChecker := &validatingadmissionpolicy.TypeChecker{
				SchemaResolver: resolver.NewDefinitionsSchemaResolver(openapi.GetOpenAPIDefinitions, scheme.Scheme),
				RestMapper:     testrestmapper.TestOnlyStaticRESTMapper(scheme.Scheme),
			}
			controller, err := NewController(
				informerFactory.Admissionregistration().V1().ValidatingAdmissionPolicies(),

// a graph that caches the dependencies as we know, and enqueues
// items to the attemptToDelete and attemptToOrphan.
type GraphBuilder struct {
	restMapper meta.RESTMapper

	// each monitor list/watches a resource, the results are funneled to the
	// dependencyGraphBuilder
	monitors    monitors
	monitorLock sync.RWMutex

	}

	garbageCollector, err := garbagecollector.NewComposedGarbageCollector(
		ctx,
		gcClientset,
		metadataClient,
		controllerContext.RESTMapper,
		controllerContext.GraphBuilder,
	)
	if err != nil {
		return nil, true, fmt.Errorf("failed to start the generic garbage collector: %w", err)
	}

	// Start the garbage collector.

	}
	return basicInfo
}

// Namespaced returns true if the object belongs to a namespace
func (i *Info) Namespaced() bool {
	if i.Mapping != nil {
		// if we have RESTMapper info, use it
		return i.Mapping.Scope.Name() == meta.RESTScopeNameNamespace
	}
	// otherwise, use the presence of a namespace in the info as an indicator
	return len(i.Namespace) > 0
}

// control.
type HorizontalController struct {
	scaleNamespacer scaleclient.ScalesGetter
	hpaNamespacer   autoscalingclient.HorizontalPodAutoscalersGetter
	mapper          apimeta.RESTMapper

	replicaCalc   *ReplicaCalculator
	eventRecorder record.EventRecorder

	downscaleStabilisationWindow time.Duration

	monitor monitor.Monitor

		t.Fatalf("Expected quotacontroller.Sync to still be running but it is blocked: %v", err)
	}
	assertMonitors(t, qc, "pods", "deployments")

	// Simulate the discovery client returning a resource the restmapper can resolve, but will not sync caches
	fakeDiscoveryClient.setPreferredResources(unsyncableServerResources, nil)

	// Wait until sync discovers the change
	time.Sleep(1 * time.Second)

    private final Function<U, T> mapper;
    private final Function<T, U> revMapper;

    WrapperList(List<U> list, Function<U, T> mapper, Function<T, U> revMapper) {
        this(() -> list, null, mapper, revMapper);
    }

    WrapperList(Supplier<List<U>> getter, Consumer<List<U>> setter, Function<U, T> mapper, Function<T, U> revMapper) {
        this.getter = getter;
        this.setter = setter;

    def rootMapper = new ThrowableToTestFailureMapper() {
        @Override
        TestFailure createFailure(Throwable throwable) {
            TestFailure.fromTestAssertionFailure(throwable, null, null, null)
        }
    }

    def "maps assertion failure correctly"() {
        when:
        def mappedFailure = mapper.map(error, rootMapper)

        then:

        final Map<String, String> remappedClassLiterals;
        private final ImplementationDependencyRelocator remapper;

        public ShadingClassRemapper(ClassWriter classWriter, ImplementationDependencyRelocator remapper) {
            super(classWriter, remapper);
            this.remapper = remapper;
            remappedClassLiterals = new HashMap<>();
        }

        @Override

    def rootMapper = new ThrowableToTestFailureMapper() {
        @Override
        TestFailure createFailure(Throwable throwable) {
            TestFailure.fromTestAssertionFailure(throwable, null, null, null)
        }
    }

    def "maps assertion failure correctly"() {
        when:
        def mappedFailure = mapper.map(error, rootMapper)

        then: