}

    /**
     * Returns the manifest for this JAR archive.
     *
     * @return The manifest
     */
    @Internal
    public Manifest getManifest() {
        return manifest;
    }

    /**
     * Sets the manifest for this JAR archive.
     *
     * @param manifest The manifest. May be null.
     */
    public void setManifest(Manifest manifest) {
        this.manifest = manifest;
    }

        then:
        def jar = new JarTestFixture(file('dest/test.jar'), 'UTF-8', 'UTF-8')
        def manifest = jar.content('META-INF/MANIFEST.MF')
        manifest.contains('moji: bak€')
        manifest.contains('bake: moji€')
    }

    @Issue('GRADLE-3374')
    def "can merge manifests containing split multi-byte chars using #taskType task"() {

     *
     * @param contentCharset the character set used to decode the merged manifest content
     * @see #getContentCharset()
     * @since 2.14
     */
    void setContentCharset(String contentCharset);

    /**
     * Adds a merge path to a manifest that should be merged into the base manifest. A merge path can be either another

            'META-INF/MANIFEST.MF',
            'org/gradle/Person.class',
            'org/gradle/resource.xml'
        )

        // Check contents of manifest
        Manifest manifest = jarContents.file('META-INF/MANIFEST.MF').withInputStream { new Manifest(it) }
        assertThat(manifest.mainAttributes.size(), equalTo(3))
        assertThat(manifest.mainAttributes.getValue('Manifest-Version'), equalTo('1.0'))

    private void copyManifestMainAttribute(Manifest source, Manifest destination, Attributes.Name name) {
        destination.getMainAttributes().put(name, source.getMainAttributes().getValue(name));
    }

    private void setManifestMainAttribute(Manifest manifest, String name, String value) {
        manifest.getMainAttributes().putValue(name, value);
    }

    private byte[] toByteArray(Manifest manifest) throws IOException {

        }

        /**
         * Specifies that this JAR has no manifest.
         */
        void withoutManifest() {
            assert !hasConfiguredManifest: "Already written the manifest"
            hasConfiguredManifest = true
        }

        /**
         * Configures the JAR manifest.
         */

    }

    @Override
    public Manifest manifest() {
        return extension.manifest();
    }

    @Override
    public Manifest manifest(@SuppressWarnings("rawtypes") Closure closure) {
        return extension.manifest(closure);
    }

    @Override
    public Manifest manifest(Action<? super Manifest> action) {
        return extension.manifest(action);
    }

    @Override

        DefaultManifest manifest = new DefaultManifest(fileResolver).attributes(key1: 'value1')
        fileResolver.resolve('file') >> manifestFile

        when:
        manifest.writeTo('file')
        Manifest fileManifest = manifestFile.withReader { new Manifest(it) }
        Manifest expectedManifest = new Manifest()

	return len(r.processedObjects) > 0 || r.deployed > 0
}

// ApplyManifest applies the manifest to create or update resources. It returns the processed (created or updated)
// objects and the number of objects in the manifests.
func (h *HelmReconciler) ApplyManifest(manifest name.Manifest) (result AppliedResult, _ error) {
	cname := string(manifest.Name)
	crHash, err := h.getCRHash(cname)
	if err != nil {
		return result, err
	}

plugins {
    id 'java'
}
version = '1.0'

// tag::add-to-manifest[]
jar {
    manifest {
        attributes("Implementation-Title": "Gradle",
                   "Implementation-Version": archiveVersion)
    }
}
// end::add-to-manifest[]

// tag::custom-manifest[]
def sharedManifest = java.manifest {
    attributes("Implementation-Title": "Gradle",
               "Implementation-Version": version)
}