) {

        // One wanted side effect of calling InstrumentationStrategy.getTransform() is also to report
        // a configuration cache problem if third-party agent is used with TestKit with configuration cache,
        // see ConfigurationCacheInjectedClasspathInstrumentationStrategy implementation.
        StandardTransform transform = instrumentationStrategy.getTransform();
        switch (transform) {
            case None:

import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.BuildTree.class)
public interface InjectedClasspathInstrumentationStrategy {
    CachedClasspathTransformer.StandardTransform getTransform();

import java.lang.management.ManagementFactory


abstract class AbstractInjectedClasspathInstrumentationStrategy : InjectedClasspathInstrumentationStrategy {
    override fun getTransform(): CachedClasspathTransformer.StandardTransform {
        val isThirdPartyAgentPresent = ManagementFactory.getRuntimeMXBean().inputArguments.find { AgentUtils.isThirdPartyJavaAgentSwitch(it) } != null

        return transformStepNode.getNodeIdentity();
    }

    @Override
    public Class<?> getTransformActionClass() {
        return transformStepNode.getTransformStep().getTransform().getImplementationClass();
    }

    @Override
    public String getTransformerName() {
        return transformerName;
    }

    @Override
    public String getSubjectName() {

        this.transformInvocationFactory = transformInvocationFactory;
        this.globalInputFingerprinter = globalInputFingerprinter;
        this.owningProject = owner.getProject();
    }

    public Transform getTransform() {
        return transform;
    }

    @Nullable
    public ProjectInternal getOwningProject() {
        return owningProject;
    }

        def artifact = Stub(ResolvableArtifact) {
            getId() >> new OpaqueComponentArtifactIdentifier(inputArtifact)
        }
        def invocation = invocationFactory.createInvocation(
            transform.getTransform(),
            inputArtifact,
            DefaultTransformUpstreamDependenciesResolver.NO_RESULT,
            TransformStepSubject.initial(artifact),
            inputFingerprinter
        )

	// It is important to set this in the newFunc rather than after InformerFor to avoid
	// https://github.com/kubernetes/kubernetes/issues/117869
	if opts.ObjectTransform != nil {
		_ = inf.SetTransform(opts.ObjectTransform)
	} else {
		_ = inf.SetTransform(stripUnusedFields)
	}
	if err := inf.SetWatchErrorHandler(informermetric.ErrorHandlerForCluster(opts.Cluster)); err != nil {

            transforms.put(transformDescription, profile);
        }
        return profile;
    }

    public CompositeOperation<FragmentedOperation> getTransforms() {
        final List<FragmentedOperation> profiles = CollectionUtils.sort(transforms.values(), Operation.slowestFirst());
        return new CompositeOperation<>(profiles);
    }

    /**

                                htmlWriter.endElement();

                                for (Operation operation : model.getTransforms()) {
                                    htmlWriter.startElement("tr");
                                        htmlWriter.startElement("td").characters(operation.getDescription()).endElement();

	if exists {
		return informer
	}

	resyncPeriod, exists := f.customResync[informerType]
	if !exists {
		resyncPeriod = f.defaultResync
	}

	informer = newFunc(f.client, resyncPeriod)
	informer.SetTransform(f.transform)
	f.informers[informerType] = informer

	return informer
}

// SharedInformerFactory provides shared informers for resources in all known
// API group versions.
//