*/

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

import org.gradle.api.JavaVersion;
import org.gradle.plugins.ide.internal.tooling.java.DefaultInstalledJdk;

import java.io.Serializable;

public class DefaultEclipseJavaSourceSettings implements Serializable {
    private JavaVersion sourceLanguageLevel;
    private JavaVersion targetBytecodeVersion;
    private DefaultInstalledJdk jdk;

        def lowerVersion = lower.javaVersion.getMajorVersion()

        and:
        goodCode()
        buildFile << """
            java.sourceCompatibility = JavaVersion.toVersion(${lowerVersion})
            java.targetCompatibility = JavaVersion.toVersion(${lowerVersion})
            java.toolchain {
                languageVersion = JavaLanguageVersion.of(${Jvm.current().javaVersion.majorVersion})
            }

    private
    fun supportedKotlinJavaVersion(version: JavaVersion = JavaVersion.current()): JavaVersion {
        val maxVersion = JavaVersion.forClassVersion(JvmTarget.supportedValues().last().majorVersion)
        return minOf(version, maxVersion)
    }

    }

    private static void validateToolchainVersion(JavaVersion version) {
        // TODO: It would be nice to enforce this as part of task configuration instead of at runtime.
        // TODO: Need to consider how to handle future versions of Java that are not yet known. This currently allows any version of Java above the minimum.
        JavaVersion minimumSupportedVersion = JavaVersion.VERSION_1_8;

        String javaVersion = metadata.get(ProbedSystemProperty.JAVA_VERSION);
        if (javaVersion == null) {
            return failure(javaHome, metadata.get(ProbedSystemProperty.Z_ERROR));
        }
        try {
            JavaVersion.toVersion(javaVersion);
        } catch (IllegalArgumentException e) {

    }

    private static com.google.testing.compile.Compiler getCompiler() {
        assumeTrue("Java 20+ do not support --release=8", Jvm.current().javaVersion < JavaVersion.VERSION_20)
        if (Jvm.current().javaVersion.isCompatibleWith(JavaVersion.VERSION_1_9)) {
            return javac().withOptions(COMPILE_OPTIONS + "--release=8")
        }
        return javac().withOptions(COMPILE_OPTIONS)
    }

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

package org.gradle.internal.buildconfiguration

import org.gradle.api.JavaVersion
import org.gradle.internal.buildconfiguration.tasks.UpdateDaemonJvmModifier
import org.gradle.internal.jvm.inspection.JvmVendor
import org.gradle.jvm.toolchain.JvmImplementation
import org.gradle.test.fixtures.file.TestFile

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

package org.gradle.buildinit.plugins

import org.gradle.api.JavaVersion
import org.gradle.buildinit.plugins.fixtures.ScriptDslFixture

class GroovyApplicationInitIntegrationTest extends AbstractJvmLibraryInitIntegrationSpec {

                id 'idea'
            }
            idea.module.languageLevel = new IdeaLanguageLevel(7)
            idea.module.targetBytecodeVersion = JavaVersion.VERSION_1_7
            java.targetCompatibility = JavaVersion.VERSION_1_8
            java.sourceCompatibility = JavaVersion.VERSION_1_8
        """

        file("lib2/build.gradle") << """
            import org.gradle.plugins.ide.idea.model.IdeaLanguageLevel

        setSourceCompatibility(JavaVersion.toVersion(value));
    }

    @Override
    public void setSourceCompatibility(JavaVersion value) {
        srcCompat = value;
    }

    @Override
    public JavaVersion getTargetCompatibility() {
        return targetCompat != null ? targetCompat : getSourceCompatibility();
    }

    public JavaVersion getRawTargetCompatibility() {