func setupNewSimpleClient(nodes []*v1.Node, pods []*v1.Pod) *fake.Clientset {
	podList := &v1.PodList{}
	for _, podItem := range pods {
		podList.Items = append(podList.Items, *podItem)
	}
	nodeList := &v1.NodeList{}
	for _, nodeItem := range nodes {
		nodeList.Items = append(nodeList.Items, *nodeItem)
	}
	return fake.NewSimpleClientset(nodeList, podList)
}

func getDeletedPodNames(client *fake.Clientset) sets.Set[string] {

        val callables = typeScope.getCallableSignatures().toList()
        return prettyPrint {
            callables.forEach {
                appendLine(stringRepresentation(it))
            }
        }
    }

    private fun KaSession.prettyPrintForTests(typeScope: KaTypeScope): String {
        val callables = typeScope.getCallableSignatures().toList()
        return prettyPrint {
            callables.forEach {

        override fun getMemberScope(analysisSession: KaSession, symbol: KaSymbolWithMembers): List<KaDeclarationSymbol> {
            with(analysisSession) {
                return symbol.getCombinedDeclaredMemberScope().getAllSymbols().toList()
            }
        }
    }

    public object ALL_DECLARED : KaRendererBodyMemberScopeProvider {

        for (RequestPostProcessorExtension postProcessor : getExtensionsByType(RequestPostProcessorExtension.class)) {
            requests = requests.stream().flatMap(request -> postProcessor.postProcessRequest(request).stream()).collect(Collectors.toList());
        }
        return requests;
    }

            .sorted(Comparator.comparing(AssessedCandidate::getDisplayName))
            .collect(Collectors.toList());
    }

    public List<AssessedCandidate> assessResolvedVariants(List<? extends ResolvedVariant> resolvedVariants) {
        return resolvedVariants.stream()

        return interceptionRequests.stream()
            .filter(request -> request.getRequestExtras().getByType(PropertyUpgradeRequestExtra.class).isPresent())
            .collect(Collectors.toList());
    }

    @Override
    public GenerationResult generateResourceForRequests(Collection<CallInterceptionRequest> filteredRequests) {
        return new GenerationResult.CanGenerateResource() {
            @Override

     *
     *     when:
     *     withInstallations(jvm1, jvm2).run(":task")
     * </pre>
     */
    AbstractIntegrationSpec withInstallations(Jvm jvm, Jvm... rest) {
        return withInstallations([jvm] + rest.toList())
    }

    AbstractIntegrationSpec withInstallations(List<Jvm> jvms) {
        def installationPaths = jvms.collect { it.javaHome.absolutePath }.join(",")
        executer

            .renderAll("packages") { prettyRenderPackage(it) }
        scope.getClassifierSymbols().toList().renderAll("classifiers") { prettyRenderDeclaration(it) }
        scope.getCallableSymbols().toList().renderAll("callables") { prettyRenderDeclaration(it) }
        scope.getConstructors().toList().renderAll("constructors") { prettyRenderDeclaration(it) }
    }

		if !contains(m.CreatedNodes[i], m.DeletedNodes) && !contains(m.CreatedNodes[i], nodes) {
			nodes = append(nodes, m.CreatedNodes[i])
		}
	}
	nodeList := &v1.NodeList{}
	for _, node := range nodes {
		nodeList.Items = append(nodeList.Items, *node)
	}
	return nodeList, nil
}

// Delete deletes a Node from the fake store.
func (m *FakeNodeHandler) Delete(_ context.Context, id string, opt metav1.DeleteOptions) error {

        val constructors = functionExtractor.constructors(kClass, preIndex)
        val name = kClass.fqName
        return DefaultDataClass(name, supertypesOf(kClass), properties, functions.toList(), constructors.toList())
    }

    private
    fun supertypesOf(kClass: KClass<*>): Set<FqName> = buildSet {
        fun visit(supertype: KType) {