def provider = new DynamicModulesClassPathProvider(moduleRegistry, pluginModuleRegistry)

        when:
        def classpath = provider.findClassPath("GRADLE_EXTENSIONS")

        then:
        classpath.asFiles.collect { it.name } == [
            "gradle-workers.jar",
            "gradle-dependency-management.jar",
            "gradle-plugin-use.jar",
            "gradle-instrumentation-declarations.jar",

     */
    @Nullable
    VersionControlSpec locateVcsFor(ModuleComponentSelector selector);

    /**
     * Does this resolver do anything?
     */
    boolean hasRules();

import org.gradle.internal.classpath.ClassPath
import org.gradle.internal.classpath.DefaultClassPath

import java.io.File


fun ClassPath.filter(predicate: (File) -> Boolean): ClassPath =

        super.setupHtmlData(runtime);
        systemHelper.setupAdminHtmlData(this, runtime);

        final Boolean editable = getUserBean()
                .map(user -> user.hasRoles(fessConfig.getAuthenticationAdminRolesAsArray()) || user.hasRole(getActionRole())).orElse(false);
        runtime.registerData("editable", editable);

inline fun withClassLoaderFor(classPath: ClassPath, action: ClassLoader.() -> Unit) =
    classLoaderFor(classPath).use(action)


fun classLoaderFor(classPath: ClassPath): URLClassLoader =
    classLoaderFor(*classPath.asFiles.toTypedArray())


fun classLoaderFor(vararg classPath: File): URLClassLoader =
    URLClassLoader.newInstance(
        classPath.map { it.toURI().toURL() }.toTypedArray()
    )


val File.normalisedPath

                    .filter(Predicates.notNull());
        } catch (ExecutionException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    public boolean hasRules(Class<?> container) {
        return !Iterables.isEmpty(getDeclaredSources(container));
    }

    private boolean isRuleSource(Class<?> clazz) {
        return RuleSource.class.isAssignableFrom(clazz);
    }

	tests := []struct {
		lc       Lifecycle
		opts     ObjectOpts
		hasRules bool
	}{
		{ // Delete marker shouldn't match filter without tags
			lc: Lifecycle{
				Rules: []Rule{
					rules[0],
				},
			},
			opts: ObjectOpts{
				DeleteMarker: true,
				IsLatest:     true,
				Name:         "obj-1",
			},
			hasRules: false,
		},
		{ // PUT version with no matching tags

      with:
        java-version: '17'
        distribution: 'temurin'
    - name: Cache Maven packages
      uses: actions/cache@v2
      with:
        path: ~/.m2
        key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
        restore-keys: ${{ runner.os }}-m2
    - name: Build with Maven
      run: mvn -B package --file pom.xml

    - name: Perform CodeQL Analysis

        HasTwoSources | [HasTwoSources.SourceOne, HasTwoSources.SourceTwo]
        IsASource     | [IsASource]
    }

    def "has model sources - #clazz"() {
        expect:
        detector.hasRules(clazz) == expected

        where:
        clazz        | expected
        String       | false
        HasOneSource | true
        IsASource    | true
    }

    def "does not hold strong reference"() {

private
fun buildOutputModel(scriptFile: File, classPath: ClassPath, sourcePath: ClassPath, implicitImports: List<String>, exceptions: List<Exception>) =
    StandardKotlinDslScriptModel(
        classPath.asFiles,
        sourcePath.asFiles,
        implicitImports,
        editorReports = emptyList(), // TODO:isolated support editor reports
        exceptions = getExceptionsForFile(scriptFile, exceptions)
    )


private