*/
    @Nullable
    public byte[] getInstrumentedClass(@Nullable String className, @Nullable ProtectionDomain protectionDomain) {
        // Even though some classes don't need instrumentation, trying to query the closed TransformReplacer is still an error.
        ensureOpened();

        if (className == null || protectionDomain == null) {

     */
    @Nullable
    byte[] instrumentClass(@Nullable String className, @Nullable ProtectionDomain protectionDomain, byte[] classfileBuffer);

    /**
     * This is called by the agent if a throwable is thrown while instrumenting a class during the call of the {@link #instrumentClass(String, ProtectionDomain, byte[])} method,

        @Nullable ProtectionDomain protectionDomain,
        byte[] classfileBuffer
    ) {
        if (!(loader instanceof InstrumentingClassLoader)) {
            return null;
        }
        InstrumentingClassLoader instrumentingLoader = (InstrumentingClassLoader) loader;
        try {
            return instrumentingLoader.instrumentClass(className, protectionDomain, classfileBuffer);

	SecretRef        *SecretReferenceApplyConfiguration `json:"secretRef,omitempty"`
	SSLEnabled       *bool                              `json:"sslEnabled,omitempty"`
	ProtectionDomain *string                            `json:"protectionDomain,omitempty"`
	StoragePool      *string                            `json:"storagePool,omitempty"`
	StorageMode      *string                            `json:"storageMode,omitempty"`

    }

    private static int getCurrentJvmMajor() {
        return JavaVersion.current().majorVersionNumber
    }

    private static ProtectionDomain protectionDomain(File path) {
        def cs = new CodeSource(path.toURI().toURL(), null as CodeSigner[])
        return new ProtectionDomain(cs, null)
    }

            errorHandler = new TransformErrorHandler(name);
        }

        @Override
        public byte[] instrumentClass(@Nullable String className, ProtectionDomain protectionDomain, byte[] classfileBuffer) {
            return replacer.getInstrumentedClass(className, protectionDomain);
        }

        @Override
        public void transformFailed(@Nullable String className, Throwable cause) {

        def cl = loader.loadClass(className)
        cl.classLoader.is(loader)
        cl.protectionDomain.codeSource.location == classesDir.toURI().toURL()
        cl.package.name == "org.gradle.api.plugins"

        def obj = JavaReflectionUtil.newInstance(cl)
        obj instanceof GroovyObject
        obj.getMetaClass()

import org.gradle.tooling.internal.provider.AbstractClassGraphSpec
import org.gradle.util.TestClassLoader
import spock.lang.Issue

import java.security.CodeSource
import java.security.Permissions
import java.security.ProtectionDomain
import java.security.cert.Certificate

class ClasspathInfererTest extends AbstractClassGraphSpec {
    def factory = new ClasspathInferer()

        }

        @Override
        public byte[] instrumentClass(@Nullable String className, ProtectionDomain protectionDomain, byte[] classfileBuffer) {
            return replacer.getInstrumentedClass(className, protectionDomain);
        }

        @Override
        public void transformFailed(@Nullable String className, Throwable cause) {

      "gateway": "gatewayValue",
      "system": "systemValue",
      "secretRef": {
        "name": "nameValue",
        "namespace": "namespaceValue"
      },
      "sslEnabled": true,
      "protectionDomain": "protectionDomainValue",
      "storagePool": "storagePoolValue",
      "storageMode": "storageModeValue",
      "volumeName": "volumeNameValue",
      "fsType": "fsTypeValue",
      "readOnly": true
    },