- `createdBy`: optional. Describes the producer of this metadata file and the contents of the module.
- `variants`: optional. Describes the variants of the component packaged in the module, if any.

### `component` value

This value must contain an object with the following values:

- `group`: The group of this component. A string
- `module`: The module name of this component. A string

        failure.assertHasCause("""No matching variant of project :buildC was found. The consumer was configured to find a library for use during runtime, compatible with Java ${JavaVersion.current().majorVersion}, packaged as a jar, preferably optimized for standard JVMs, and its dependencies declared externally but:
  - No variants exist.""")
    }

    public static final REPOSITORY_HINT = repositoryHint("Maven POM")

[[sec:java_packaging]]
== Packaging and publishing

How you package and potentially publish your Java project depends on what type of project it is.
Libraries, applications, web applications and enterprise applications all have differing requirements.
In this section, we will focus on the bare bones provided by the Java Library Plugin.

- `createdBy`: optional. Describes the producer of this metadata file and the contents of the module.
- `variants`: optional. Describes the variants of the component packaged in the module, if any.

### `component` value

This value must contain an object with the following values:

- `group`: The group of this component. A string
- `module`: The module name of this component. A string

	}
}

// WriteImportcfg writes an importcfg file used by the compiler or linker to
// dstPath containing entries for the file mappings in packageFiles, as well
// as for the packages transitively imported by the package(s) in pkgs.
//
// pkgs may include any package pattern that is valid to pass to 'go list',
// so it may also be a list of Go source files all in the same directory.

            import ${gradleBaseServicesClass.name};
            public class Java {}
        """

        then:
        fails("compileJava")
        failure.assertHasErrorOutput("package ${gradleBaseServicesClass.package.name} does not exist")
    }

    def "gradle classpath does not leak onto java compile classpath"() {
        given:
        file("src/main/java/Example.java") << """

====

== Making variants published as classified jars explicit ==

While in the previous example, all variants, "main variants" and optional features, were packaged in one jar file, it is common to publish certain variants as separate files.
In particular, when the variants are mutual exclusive — i.e. they are *not* feature variants, but different variants offering alternative choices.

The ID is derived from the plugin script's filename and its (optional) package declaration.

For example, the script `src/main/\*/java-library.gradle(.kts)` has a plugin ID of `java-library` (assuming it has no package declaration).
Likewise, `src/main/*/my/java-library.gradle(.kts)` has a plugin ID of `my.java-library` as long as it has a package declaration of `my`.

Precompiled script plugin names have two important limitations:

This is for example the case when between projects you share a _directory of files_, but there's no way you can publish a _directory_ directly on a Maven repository (only packaged things like jars or zips).
Look at the link:{javadocPath}/org/gradle/api/component/ConfigurationVariantDetails.html[ConfigurationVariantDetails] class for details about how to skip publication of a particular variant.

Use the `test` task provided by the Java Plugin.
It runs the unit tests, and more specifically, the tests that make up the <<java_plugin.adoc#source_sets,`test` source set>>.

`package`::
Use the `assemble` task provided by the Base Plugin.
This builds whatever is the appropriate package for the project; for example, a JAR for Java libraries or a WAR for traditional Java webapps.

`verify`::
Use the `check` task provided by the Base Plugin.