destinationDirectory = buildDir.dir("classes/java/test")
                sourceCompatibility = "${compileJavaVersion}"
                targetCompatibility = "${compileJavaVersion}"
            }

            task test(type: Test) {
                testClassesDirs = buildDir.files("classes/java/test")
                classpath = files(configurations.testImplementation, buildDir.dir("classes/java/test"))

        run("build")

        then:
        new JarTestFixture(file("build/libs/oldjava.jar")).javaVersion == version
        getClassMajorVersion(file ( "build/classes/java/main/Thing.class")) == TestJavaClassUtil.getClassVersion(version)
        getClassMajorVersion(file("build/classes/java/test/ThingTest.class")) == TestJavaClassUtil.getClassVersion(version)
        new DefaultTestExecutionResult(testDirectory).assertTestClassesExecuted("ThingTest")

        JavaLanguageVersion javaLanguageVersion = JavaLanguageVersion.of(forkingSpec.getJavaLanguageVersion());
        if (javaLanguageVersion.canCompileOrRun(9)) {
            // In JDK 9 and above the compiler internal classes are bundled with the rest of the JDK, but we need to export it to gain access.
            javaForkOptions.jvmArgs(
                "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Shared classes for projects requiring GPG support"

errorprone {
    disabledChecks.addAll(
        "DefaultCharset", // 1 occurrences
    )
}

dependencies {
    api(project(":core-api"))
    api(project(":resources"))

    api(libs.bouncycastlePgp)
    api(libs.jsr305)

    implementation(projects.stdlibJavaExtensions)

plugins {
    id("gradlebuild.distribution.implementation-kotlin")
    id("gradlebuild.publish-public-libraries")

    embeddedKotlin("plugin.serialization")
}

description = "Common shared classes used by the Declarative DSL"

tasks.withType<KotlinCompile>().configureEach {
    compilerOptions {
        apiVersion.set(KotlinVersion.KOTLIN_1_9)
        languageVersion.set(KotlinVersion.KOTLIN_1_9)
    }
}

                    artifact name: 'main', extension: '', type: 'java-classes-directory'
                }
                project(":lib", "test:lib:") {

import org.jetbrains.kotlin.analysis.api.symbols.markers.KaSymbolWithTypeParameters

/**
 * Represents a symbol of declaration which can be directly expressed in source code.
 * Eg, classes, type parameters or functions are [KaDeclarationSymbol], but files and packages are not
 */
public sealed interface KaDeclarationSymbol : KaSymbol, KaSymbolWithTypeParameters, KaAnnotatedSymbol

                                        // .collect() is intentional for a better error message on failure
                                        // The 6 elements are: junit, hamcrest, test classes and resources, main classes and resources
                                        assert classpath.collect().size() == 6
                                        assert classpath.any { it.name == "junit-${JUnit4TestToolchain.DEFAULT_VERSION}.jar" }

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Contains classes implementing an enhanced dependency resolution API, intended to
 * replace resolvable configurations.
 */
@org.gradle.api.NonNullApi

    testImplementation(project(":model-core"))

    integTestImplementation(project(":logging")) {
        because("This isn't declared as part of integtesting's API, but should be as logging's classes are in fact visible on the API")
    }
    integTestImplementation(project(":build-option"))
    integTestImplementation(project(":enterprise-operations"))