import org.gradle.internal.jvm.Jvm
import org.gradle.util.internal.TextUtil

class CommandLineJavaCompilerIntegrationTest extends AbstractJavaCompilerIntegrationSpec {

    @Override
    String compilerConfiguration() {
        """
            compileJava.options.with {
                fork = true
                forkOptions.javaHome = file("${TextUtil.normaliseFileSeparators(Jvm.current().javaHome.toString())}")
            }

    def canEnableAndDisableInvokeDynamicOptimization() {
        when:
        run("sanityCheck")

        then:
        noExceptionThrown()
    }

    String compilerConfiguration() {
        '''
tasks.withType(GroovyCompile) {
    groovyOptions.fork = false
}
        '''
    }

        compilerConfiguration: CompilerConfiguration = CompilerConfiguration(),
        classLoader: ClassLoader = MockProject::class.java.classLoader,
    ): KotlinCoreProjectEnvironment {
        val applicationEnvironment = KotlinCoreEnvironment.getOrCreateApplicationEnvironment(
            projectDisposable = projectDisposable,
            compilerConfiguration,
            applicationEnvironmentMode,
        )

internal class KaFe10CompilerFacility(
    override val analysisSession: KaFe10Session
) : KaCompilerFacility(), KaFe10SessionComponent {
    override fun compile(
        file: KtFile,
        configuration: CompilerConfiguration,
        target: KaCompilerTarget,
        allowedErrorFilter: (KaDiagnostic) -> Boolean
    ): KaCompilationResult {
        if (file is KtCodeFragment) {

<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
    <component name="CompilerConfiguration">
        <option name="DEFAULT_COMPILER" value="Javac"/>
        <resourceExtensions>
            <entry name=".+\.(properties|xml|html|dtd|tld)"/>
            <entry name=".+\.(gif|png|jpeg|jpg)"/>
        </resourceExtensions>
        <wildcardResourcePatterns>
        </wildcardResourcePatterns>

            return ipr.component."@project-jdk-name"
        }
        return null
    }

    def getBytecodeTargetLevel() {
        def compilerConfig = ipr.component.find { it.@name == "CompilerConfiguration" }
        return compilerConfig.bytecodeTargetLevel
    }

    def getLibraryTable() {
        return ipr.component.find {
            it.@name == "libraryTable"
        }
    }

 * limitations under the License.
 */

package org.gradle.process.internal

import org.codehaus.groovy.control.CompilationUnit
import org.codehaus.groovy.control.CompilerConfiguration
import org.gradle.api.internal.ClassPathRegistry
import org.gradle.api.internal.DefaultClassPathProvider
import org.gradle.api.internal.DefaultClassPathRegistry
import org.gradle.api.internal.classpath.ModuleRegistry

import org.gradle.util.internal.TextUtil
import spock.lang.Issue

class DaemonJavaCompilerIntegrationTest extends AbstractJavaCompilerIntegrationSpec {

    @Override
    String compilerConfiguration() {
        """
            tasks.withType(JavaCompile) {
                options.fork = true
            }
        """
    }

    @Override
    String logStatement() {
        "compiler daemon"

        """

        expect:
        succeeds "compileGroovy"
        groovyClassFile("Thing.class").exists()
        groovyClassFile("JavaThing.class").exists()
    }

    @Override
    String compilerConfiguration() {
        "tasks.withType(GroovyCompile) { groovyOptions.fork = true }"
    }

import org.jetbrains.kotlin.codegen.CodegenFactory
import org.jetbrains.kotlin.codegen.state.GenerationState
import org.jetbrains.kotlin.config.CommonConfigurationKeys
import org.jetbrains.kotlin.config.CompilerConfiguration
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.diagnostics.*
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.diagnostics.toFirDiagnostics