return "(String)System.getProperties().get(\"$name\")"
            }

            @Override
            String getGroovyExpression() {
                return "System.properties[\"$name\"]"
            }

            @Override
            String getKotlinExpression() {
                return "System.getProperties()[\"$name\"]"
            }
        }
    }

            import ${Plugin.name};
            import ${Project.name};
            import ${Properties.name};

            public class SomePlugin implements Plugin<Project> {
                public void apply(Project project) {
                    Properties newProps = new Properties();
                    System.getProperties().forEach(newProps::put);

            @CompileStatic
            class SomePlugin implements Plugin<Project> {
                void apply(Project project) {
                    def newProps = new Properties()
                    System.properties.forEach { k, v -> newProps[k] = v }
                    newProps.replace("some.property", "new.value")
                    ${setProperties}(newProps)
                }
            }

            import static ${System.name}.setProperties

            class SomePlugin implements Plugin<Project> {
                void apply(Project project) {
                    def newProps = new Properties()
                    System.properties.forEach { k, v -> newProps[k] = v }
                    newProps.replace("some.property", "new.value")
                    ${setProperties}(newProps)

        return new SystemPropertyInjection() {
            @Override
            String getDescription() {
                return "using gradle.properties"
            }

            @Override
            void setup(AbstractConfigurationCacheIntegrationTest test) {
                test.file("gradle.properties").text = "systemProp.${prop}=${value}"
            }
        }
    }

            """
        }
    }

    static class BuildSrc extends BuildWithGradleProperties {

        @Override
        void setup(AbstractIntegrationSpec spec) {
            spec.file("buildSrc/gradle.properties") << "bar=101"
            spec.file("buildSrc/build.gradle") << echoTaskForProperty("bar")
        }

        @Override
        String task() {
            return ":buildSrc:echo"
        }

        cacheDir.listFiles().length == 3 // gc file + cache properties + 'help' state
    }

    private TestFile createCacheEntryDir(String entry) {
        TestFile dir = cacheDir.createDir(entry)
        dir.createFile("state.bin")
        dir.createFile("fingerprint.bin")
        return dir
    }

    private TestFile getGcFile() {
        return cacheDir.file("gc.properties")
    }

    private TestFile getCacheDir() {

        outputContains("exists = false")
        problems.assertResultHasProblems(result) {
            withInput("Build file 'build.gradle': file system entry")
        }

        when:
        file("gradle.properties") << """$IGNORE_FS_CHECKS_PROPERTY=build/*.lock"""
        configurationCacheRun()

        then:
        outputContains("exists = false")
        problems.assertResultHasProblems(result) {
            withNoInputs()

/**
 * Implements [KaNamedClassOrObjectSymbol] for a Java class. The underlying [firSymbol] is built lazily and only when needed. Many simple
 * properties are computed from the given [PsiClass] instead of [firSymbol]. This improves performance when "slow" properties don't need to
 * be accessed.
 */
internal class KaFirPsiJavaClassSymbol(
    override val psi: PsiClass,
    override val analysisSession: KaFirSession,

    testRuntimeOnly(project(":distributions-core")) {
        because("NonTransformedModelDslBackingTest instantiates DefaultClassLoaderRegistry which requires a 'gradle-plugins.properties' through DefaultPluginModuleRegistry")
    }
    integTestDistributionRuntimeOnly(project(":distributions-core"))