getToolingApiResourcesDir(connectionImplementation),
            ClasspathUtil.getClasspathForClass(TestConnection.class),
            ClasspathUtil.getClasspathForClass(ActorFactory.class),
            ClasspathUtil.getClasspathForClass(Logger.class),
            ClasspathUtil.getClasspathForClass(GroovyObject.class),
            ClasspathUtil.getClasspathForClass(GradleVersion.class))

        when:

            }
        }.visit(classLoader);
    }

    public static File getClasspathForClass(String targetClassName) {
        try {
            Class<?> clazz = Class.forName(targetClassName);
            if (clazz.getClassLoader() == null) {
                return null;
            } else {
                return getClasspathForClass(Class.forName(targetClassName));
            }
        } catch (ClassNotFoundException e) {

    GroovyCompileTransformingClassLoader loader
    Class<?> classAnnotation

    def setup() {
        def classPath = DefaultClassPath.of(ClasspathUtil.getClasspathForClass(getClass()), ClasspathUtil.getClasspathForClass(GroovyASTTransformationClass))
        loader = new GroovyCompileTransformingClassLoader(null, classPath)
        classAnnotation = loader.loadClass(GroovyASTTransformationClass.name)
    }

        c.getConstructor().newInstance().doStuff()

        then:
        notThrown()
    }

    def getClasspath() {
        return DefaultClassPath.of(ClasspathUtil.getClasspathForClass(DefaultClassLoaderFactoryTestHelper))
    }

import javax.xml.parsers.SAXParserFactory;
import java.io.File;
import java.util.Collections;

import static java.lang.ClassLoader.getSystemClassLoader;
import static org.gradle.internal.classloader.ClasspathUtil.getClasspathForClass;
import static org.gradle.internal.classloader.ClasspathUtil.getClasspathForResource;

public class DefaultClassLoaderFactory implements ClassLoaderFactory {

class ClassLoaderUtilsTest extends Specification {
    def 'can inject classes to a classloader'() {
        given:
        Class testClass = DefaultClassLoaderFactoryTestHelper
        File classpath = ClasspathUtil.getClasspathForClass(testClass)
        File classFile = new File(classpath, testClass.name.replace('.', '/') + '.class')
        byte[] bytes = Files.readAllBytes(classFile.toPath())
        MyClassLoader myClassLoader = new MyClassLoader()

        isolated.isolate() == Type1.TWO
    }

    def "can coerce enum value"() {
        def loader = new GroovyClassLoader(getClass().getClassLoader().parent)
        loader.addURL(ClasspathUtil.getClasspathForClass(GroovyObject).toURI().toURL())
        def cl = loader.parseClass("package ${Type1.package.name}; enum Type1 { TWO, THREE } ")
        assert cl != Type1
        assert cl.name == Type1.name

        expect:

        } else {
            return new CurrentGradleInstallation(new GradleInstallation(dir));
        }
    }

    private static File findDistDir(Class<?> clazz) {
        File codeSource = ClasspathUtil.getClasspathForClass(clazz);
        if (codeSource.isFile()) {
            return determineDistRootDir(codeSource);
        } else {
            // Loaded from a classes dir - assume we're running from the ide or tests

        def destDir = destinationDirectory.get().asFile
        fs.delete {
            delete(destDir, temporaryDir)
        }

        def xslClasspath = classpath.plus(objects.fileCollection().from(ClasspathUtil.getClasspathForClass(XslTransformer)))

        fs.copy {
            from(getStylesheetDirectory()) {
                include "**/*.xml"
                include "*.xsl"
            }

    static ClassLoader getToolingApiClassLoader(ToolingApiDistribution toolingApi, Class<?> target) {
        def testClassPath = [ToolingApiSpecification, target]
            .collect { ClasspathUtil.getClasspathForClass(it) }

        testClassPath.addAll(collectAdditionalClasspath(toolingApi, target))

        getTestClassLoader(toolingApi, testClassPath)
    }