<artifactId>maven-from-plugins-plugin</artifactId>
        <version>1.0</version>
      </plugin>
    </plugins>
  </build>

  <reporting>
    <plugins>
      <plugin>
        <artifactId>maven-noversion-plugin</artifactId>
      </plugin>
      <plugin>
        <artifactId>maven-from-plugins-plugin</artifactId>
      </plugin>
      <plugin>
        <artifactId>maven-from-pluginManagement-plugin</artifactId>

        if (version != null && version instanceof String && ((String) version).startsWith("JDK_")) {
            level = (String) version;
            return;
        }
        level = JavaVersion.toVersion(version).name().replaceFirst("VERSION", "JDK");
    }

    public String getLevel() {
        return level;
    }

    public void setLevel(String level) {
        this.level = level;
    }

        JavaVersion.forClass(groovyClassFile("GroovyBar.class").bytes) == javaVersion

        where:
        javaVersion << ["1.6", "1.7", "1.8"].collect { JavaVersion.toVersion(it) }
    }

     * @return The version, or null if the provided value is null.
     * @throws IllegalArgumentException when the provided value cannot be converted.
     */
    public static JavaVersion toVersion(Object value) throws IllegalArgumentException {
        if (value == null) {
            return null;
        }
        if (value instanceof JavaVersion) {
            return (JavaVersion) value;
        }

        project.sourceSets.create('custom')

        then:
        JavaVersion.toVersion(project.tasks.compileJava.getSourceCompatibility()).majorVersion == Jvm.current().javaVersion.majorVersion
        JavaVersion.toVersion(project.tasks.compileJava.getTargetCompatibility()).majorVersion == Jvm.current().javaVersion.majorVersion

    public JavaVersion getSourceCompatibility() {
        if (srcCompat != null) {
            return srcCompat;
        } else if (toolchainSpec != null && toolchainSpec.isConfigured()) {
            return JavaVersion.toVersion(toolchainSpec.getLanguageVersion().get().toString());
        } else {
            return JavaVersion.current();
        }
    }

    public JavaVersion getRawSourceCompatibility() {
        return srcCompat;

        when:
        javaCompile.javaCompiler.set(compiler)
        def spec = javaCompile.createSpec()

        then:
        spec.sourceCompatibility == JavaVersion.toVersion(toolchainVersion).toString()
        spec.targetCompatibility == JavaVersion.toVersion(toolchainVersion).toString()
        spec.release == null
        spec.compileOptions.forkOptions.javaHome == null
        (spec as ForkingJavaCompileSpec).javaHome == javaHome

  #set ( $ioVersion = $Version.getConstructor( $package.class ).newInstance( $forcedIOModelVersion ) )
#else
  #set ( $ioVersion = $version )
#end
#set ( $namespace = $xmlModelMetadata.getNamespace($ioVersion) )
#set ( $schemaLocation = $xmlModelMetadata.getSchemaLocation($ioVersion) )
#set ( $rootXml = $Helper.xmlClassMetadata( $root ) )
#set ( $rootTag = $rootXml.tagName )

        TestedVersions.gretty.findAll {
            JavaVersion.current().isCompatibleWith(it.javaMinVersion as JavaVersion) &&
                (it.javaMaxVersion == null || JavaVersion.current() <= JavaVersion.toVersion(it.javaMaxVersion))
        }
    }

        AttributeValue<Integer> jvmVersionAttribute = failure.getRequestedAttributes().findEntry(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE);
        return JavaVersion.toVersion(jvmVersionAttribute.get());
    }

    @Override
    public boolean canDescribeFailure(IncompatibleGraphVariantFailure failure) {