}

    @Provides
    Symlink createWindowsJdkSymlink() {
        if (JavaVersion.current().isJava7Compatible()) {
            return new WindowsJdk7Symlink();
        } else {
            return new WindowsSymlink();
        }
    }

    @Provides
    Symlink createJdkSymlink(TemporaryFileProvider temporaryFileProvider) {
        if (JavaVersion.current().isJava7Compatible()) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.model.internal.type

import org.gradle.api.JavaVersion
import spock.lang.Specification

class ModelTypesTest extends Specification {
    def "collects type hierarchy of #types.simpleName to #closed.simpleName"() {
        expect:

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.plugins.ide.eclipse.model.internal;

import org.gradle.api.JavaVersion;

/**
 * Utility class for saving Java versions in Eclipse descriptors.
 */
public class EclipseJavaVersionMapper {

    private EclipseJavaVersionMapper() {
    }

    /**

    class Target(override val project: Project) : PrecompiledScriptPluginsSupport.Target {

        override val jvmTarget: Provider<JavaVersion> =
            DeprecationLogger.whileDisabled(Factory {
                @Suppress("DEPRECATION")
                project.kotlinDslPluginOptions.jvmTarget.map { JavaVersion.toVersion(it) }
            })!!

        override val kotlinSourceDirectorySet: SourceDirectorySet

    private final static String UNSUPPORTED_COMPILATION_CLASSPATH_VERSION = '0.26.0'

    private static String supportedCompilationClasspathVersion() {
        if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_16)) {
            return "1.6"
        }
        return MIN_SUPPORTED_COMPILATION_CLASSPATH_VERSION
    }

    def "compilation classpath can be specified for a CodeNarc task"() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.kotlin.dsl.provider

import org.gradle.api.JavaVersion
import org.gradle.api.Project
import org.gradle.api.file.SourceDirectorySet
import org.gradle.api.provider.Provider

import java.io.File


/**

        });
    }

    private static JavaVersion computeJavaSourceCompatibilityConvention(DefaultJavaPluginExtension javaExtension, ScalaCompile compileTask) {
        JavaVersion rawSourceCompatibility = javaExtension.getRawSourceCompatibility();
        if (rawSourceCompatibility != null) {
            return rawSourceCompatibility;
        }

class JavaModuleCrossCompileIntegrationTest extends AbstractJavaModuleIntegrationTest {

    def setup() {
        buildFile << """
            java {
                sourceCompatibility = JavaVersion.VERSION_1_8
                targetCompatibility = JavaVersion.VERSION_1_8
            }
            def jvm = project.services.get(org.gradle.api.plugins.jvm.internal.JvmLanguageUtilities)

            def main = sourceSets.main

 */
fun alpnBootVersion(): String? {
  val version = System.getProperty("alpn.boot.version")

  if (version != null) {
    return version
  }

  val javaVersion = System.getProperty("java.version")
  val match = "1\\.8\\.0_(\\d+)(-.*)?".toRegex().find(javaVersion) ?: return null

  return alpnBootVersionForPatchVersion(match.groupValues.first().toInt())

 * limitations under the License.
 */

package org.gradle.test.fixtures.archive

import org.apache.commons.compress.archivers.zip.ZipFile
import org.apache.commons.io.IOUtils
import org.gradle.api.JavaVersion
import org.gradle.internal.lazy.Lazy
import org.gradle.internal.serialize.JavaClassUtil

import java.util.jar.JarEntry
import java.util.jar.JarFile
import java.util.jar.Manifest