def cl = urlClassLoader(toolingApiClassPath + isolatedClasses(CustomAction, CustomModel))
        def actionClass = cl.loadClass(CustomAction.name)

        expect:
        def classpath = classpathFor(actionClass)
        def loader = new VisitableURLClassLoader("test", ClassLoader.systemClassLoader.parent, classpath)
        def action = JavaReflectionUtil.newInstance(loader.loadClass(CustomAction.name))

            plugins { java }
        """)

        and:
        withFile("gradle.properties", "org.gradle.kotlin.dsl.accessors=off")

        expect:
        assertThat(
            classPathFor(projectDir, buildFile),
            not(hasAccessorsClasses())
        )
    }

    def "the set of jit accessors is a function of the set of applied plugins"() {

        given:

        def accessorsClassPath = accessorsClassPathFor(settingsFileKts)

        then:
        !accessorsClassPath.isEmpty()
    }

    private List<File> accessorsClassPathFor(File buildFile) {
        return classPathFor(projectDir, buildFile)
            .tap { println(it) }
            .findAll { isAccessorsDir(it) }
    }

    private static boolean isAccessorsDir(File dir) {

    }

    protected List<File> canonicalClassPathFor(File projectDir, File scriptFile = null) {
        return canonicalClasspathOf(kotlinBuildScriptModelFor(projectDir, scriptFile))
    }

    protected List<File> classPathFor(File projectDir, File scriptFile = null) {
        return kotlinBuildScriptModelFor(projectDir, scriptFile).classPath
    }

    protected List<File> sourcePathFor(File scriptFile) {

    protected
    fun jarClassPathWith(path: String, vararg classes: KClass<*>): ClassPath = classPathOf(
        file(path).also { jar ->
            zipTo(jar, classEntriesFor(classes))
        }
    )

    protected
    fun classPathWith(vararg classes: KClass<*>): ClassPath = classPathOf(
        newFolder().also { rootDir ->
            for ((path, bytes) in classEntriesFor(classes)) {

            int count = inputStream.readInt();
            StringBuilder classpathStr = new StringBuilder();
            for (int i = 0; i < count; i++) {
                String entry = inputStream.readUTF();
                File file = new File(entry);
                addUrlMethod.invoke(systemClassLoader, file.toURI().toURL());
                if (i > 0) {
                    classpathStr.append(File.pathSeparator);
                }

        if (plugin == null) {
            String classpathStr = injectedClasspath.getAsFiles().stream().map(File::getAbsolutePath).collect(Collectors.joining(File.pathSeparator));
            return PluginResolutionResult.notFound(getDescription(), "classpath: " + classpathStr);
        } else {
            return PluginResolutionResult.found(new InjectedClasspathPluginResolution(plugin));

    val cachedClassPaths = hashMapOf<ClassLoader, Set<File>>()

    fun of(classLoader: ClassLoader): Set<File> =
        cachedClassPaths.getOrPut(classLoader) {
            classPathOf(classLoader)
        }

    private
    fun classPathOf(classLoader: ClassLoader): Set<File> {
        val classPathFiles = mutableSetOf<File>()

        object : ClassLoaderVisitor() {

        val srcDir = newFolder("src")
        val binDir = newFolder("bin")

        // when:
        withSynchronousIO {
            buildPluginDependencySpecAccessorsFor(
                pluginDescriptorsClassPath = classPathOf(pluginsJar),
                srcDir = srcDir,
                binDir = binDir
            )
        }

        // then: