private final ExternalResourceUploader uploader;
    private final ExternalResourceLister lister;
    // Should really be a parameter to the 'withContent' methods or baked into the accessor
    private final boolean revalidate;

    public AccessorBackedExternalResource(ExternalResourceName name, ExternalResourceAccessor accessor, ExternalResourceUploader uploader, ExternalResourceLister lister, boolean revalidate) {

	var fn func(ctxt *Link, sect *sym.Section, syms []loader.Sym)
	var wg sync.WaitGroup
	var sem chan int
	if ctxt.Out.isMmapped() {
		// Write sections in parallel.
		sem = make(chan int, 2*runtime.GOMAXPROCS(0))
		fn = func(ctxt *Link, sect *sym.Section, syms []loader.Sym) {
			wg.Add(1)
			sem <- 1

    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)
    }

            }
        """)
        !GroovyObject.isAssignableFrom(original)

        expect:
        def loader = new MixInLegacyTypesClassLoader(groovyClassLoader, DefaultClassPath.of(classesDir), new DefaultLegacyTypesSupport())

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

}

// inittaskSym builds a symbol containing pointers to all the inittasks
// that need to be run, given a list of root inittask symbols.
func (ctxt *Link) inittaskSym(rootNames []string, symName string) loader.Sym {
	ldr := ctxt.loader
	var roots []loader.Sym
	for _, n := range rootNames {
		p := ldr.Lookup(n, 0)
		if p != 0 {
			roots = append(roots, p)
		}
	}
	if len(roots) == 0 {
		// Nothing to do
		return 0
	}

    private static final Loader SKIP_INSTRUMENTATION = new Loader();
    private final ConcurrentMap<ProtectionDomain, Loader> loaders;
    private final TransformedClassPath classPath;
    private volatile boolean closed;

    public TransformReplacer(TransformedClassPath classPath) {
        this.loaders = new ConcurrentHashMap<ProtectionDomain, Loader>();
        this.classPath = classPath;
    }

    /**

        given:
        def loader = Mock(IGradlePropertiesLoader)
        def controller = new DefaultGradlePropertiesController(loader, Mock(SystemPropertiesInstaller), Mock(ProjectPropertiesLoader))
        def settingsDir = new File('.')
        def properties = controller.gradleProperties
        def loadedProperties = Mock(MutableGradleProperties)
        1 * loader.loadGradleProperties(settingsDir) >> loadedProperties

import (
	"cmd/internal/obj"
	"cmd/link/internal/loader"
	"cmd/link/internal/sym"
	"sync"
)

type unresolvedSymKey struct {
	from loader.Sym // Symbol that referenced unresolved "to"
	to   loader.Sym // Unresolved symbol referenced by "from"
}

type symNameFn func(s loader.Sym) string

// ErrorReporter is used to make error reporting thread safe.
type ErrorReporter struct {
	loader.ErrorReporter

        ChildFirstClassLoader(getSystemClassLoader(), classPathWith(DeepThought::class.java)).use { loader ->

            val `class` = loader.loadClass(DeepThought::class.qualifiedName)

            val targetScope = mock<AbstractClassLoaderScope> {
                on { localClassLoader } doReturn loader
                on { exportClassLoader } doReturn loader.parent
                on { parent }.then { it.mock }

    /**
     * Gets the class loader from which to load any types referenced by the configuration. If unset, the class loader of
     * the bean class will be used.
     *
     * @return The class loader to load referenced types from or {@code null} if unset.
     */
    ClassLoader getClassLoader();

    /**