import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
import org.jetbrains.kotlin.codegen.ClassBuilderFactory
import org.jetbrains.kotlin.config.CompilerConfiguration
import org.jetbrains.kotlin.config.CommonConfigurationKeys
import org.jetbrains.kotlin.config.CompilerConfigurationKey
import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.psi.KtCodeFragment

import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
import org.jetbrains.kotlin.cli.jvm.config.jvmModularRoots
import org.jetbrains.kotlin.config.CommonConfigurationKeys
import org.jetbrains.kotlin.config.CompilerConfiguration
import org.jetbrains.kotlin.config.JVMConfigurationKeys
import org.jetbrains.kotlin.idea.KotlinFileType
import org.jetbrains.kotlin.parsing.KotlinParserDefinition
import org.jetbrains.kotlin.platform.jvm.JvmPlatforms

 * limitations under the License.
 */
package org.gradle.java.compile

class InProcessJavaCompilerIntegrationTest extends AbstractJavaCompilerIntegrationSpec {

    @Override
    String compilerConfiguration() {
        """
            compileJava.options.with {
                fork = false
            }
        """
    }

    @Override
    String logStatement() {
        "Java compiler API"
    }

        val compilerConfiguration = compilerConfigurationProvider.getCompilerConfiguration(testModule)
        val project = compilerConfigurationProvider.getProject(testModule)
        val packageProviderFactory = compilerConfigurationProvider.getPackagePartProviderFactory(testModule)
        JvmResolveUtil.analyze(project, ktTestModule.ktFiles, compilerConfiguration, packageProviderFactory)
    }

import org.gradle.internal.jvm.Jvm

import org.gradle.util.internal.TextUtil

class CommandLineJavaCompilerForExecutableIntegrationTest extends AbstractJavaCompilerIntegrationSpec {

    @Override
    String compilerConfiguration() {
        """
            compileJava.options.with {
                fork = true
                forkOptions.executable = "${TextUtil.normaliseFileSeparators(Jvm.current().getExecutable("javac").absolutePath)}"

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

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

 * 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"