import org.gradle.internal.jvm.Jvm

apply plugin: "java"

sourceSets {
    taglet
}

dependencies {
    if (Jvm.current().toolsJar) {
        tagletImplementation files(Jvm.current().toolsJar)
    }
}

javadoc {
    dependsOn tagletClasses
    options {
        locale = 'de_DE'
        breakIterator = true
        taglets 'LocaleAwareTaglet'
        tagletPath sourceSets.taglet.java.destinationDirectory.get().asFile

import org.gradle.internal.jvm.Jvm

apply plugin: "java"

sourceSets {
    taglet
}

dependencies {
    if (Jvm.current().toolsJar) {
        tagletImplementation files(Jvm.current().toolsJar)
    }
}

javadoc {
    dependsOn tagletClasses

    options {
        tags 'author'
        tags 'deprecated'
        tags 'customtag:t:"Custom Tag:"'
        taglets 'CustomTaglet'

        <jdkHome>${env.JAVA_HOME}</jdkHome>
        <toolsJar>lib/tools.jar</toolsJar>
     </configuration>
  </toolchain>
  <toolchain>
     <type>jdk</type>
     <provides>
         <version>1.6</version>
         <vendor>sun</vendor>
     </provides>
     <configuration>
        <jdkHome>${env.JAVA_HOME}</jdkHome>
        <toolsJar>lib/classes.jar</toolsJar>
     </configuration>
  </toolchain>

        // Add in tools.jar to the systemClassloader parent
        File toolsJar = Jvm.current().getToolsJar();
        if (toolsJar != null) {
            final ClassLoader systemClassLoaderParent = classLoaderFactory.getIsolatedSystemClassLoader();
            ClasspathUtil.addUrl((URLClassLoader) systemClassLoaderParent, DefaultClassPath.of(toolsJar).getAsURLs());
        }
    }

            File toolsJar = jvm.getToolsJar();
            if (toolsJar == null) {
                throw new IllegalStateException("Could not find tools.jar in " + jvm.getJavaHome());
            }

            compilerClasspath = compilerClasspath.plus(
                Collections.singletonList(toolsJar)
            );
        }

            assertEquals("lib/tools.jar", config0.getChild("toolsJar").getValue());
            assertEquals(2, config0.getChildCount());
            Xpp3Dom config1 = (Xpp3Dom) jdks.getToolchains().get(1).getConfiguration();
            assertEquals(2, config1.getChildCount());
            assertEquals("lib/classes.jar", config1.getChild("toolsJar").getValue());
            assertEquals(2, jdksExtend.getToolchains().size());

        if (Registry.is("project.structure.add.tools.jar.to.new.jdk", false)) {
            @SuppressWarnings("IdentifierGrammar") Path toolsJar = home.resolve("lib/tools.jar");
            if (Files.isRegularFile(toolsJar)) {
                rootFiles.add(toolsJar);
            }
        }

        Set<String> pathFilter = CollectionFactory.createFilePathSet();
        for (Path jarDir : jarDirs) {

    testImplementation(projectTests(":analysis:low-level-api-fir"))

    testImplementation(kotlinTest("junit"))
    testCompileOnly(toolsJarApi())
    testRuntimeOnly(toolsJar())
    testApi(platform(libs.junit.bom))
    testImplementation(libs.junit.jupiter.api)
    testRuntimeOnly(libs.junit.jupiter.engine)
}

kotlin {
    explicitApi()
}

sourceSets {

    testImplementation(projectTests(":analysis:analysis-test-framework"))
    testImplementation(commonDependency("org.jetbrains.kotlin:kotlin-reflect")) { isTransitive = false }
    testCompileOnly(toolsJarApi())
    testRuntimeOnly(toolsJar())
}

sourceSets {
    "main" { projectDefault() }
    "test" { projectDefault() }
}

tasks.withType<KotlinJvmCompile>().configureEach {
    compilerOptions.freeCompilerArgs.add("-Xcontext-receivers")

    testImplementation(kotlinTest("junit"))
    testApi(projectTests(":analysis:analysis-test-framework"))

    testCompileOnly(toolsJarApi())
    testRuntimeOnly(toolsJar())
    testApi(platform(libs.junit.bom))
    testImplementation(libs.junit.jupiter.api)
    testRuntimeOnly(libs.junit.jupiter.engine)
}

sourceSets {
    "main" { projectDefault() }
    "test" {