*     jar("path/to/file.jar") {
     *         manifest {  // can be withoutManifest()
     *             mainAttributes.putValue("Multi-Release", "true")
     *         }
     *
     *         entry("Foo.class", fooBytes)
     *         versionedEntry(11, "Foo.class", fooBytesForJava11)
     *     }
     *
     * </pre>
     * @param jarFile the jar file to create
     * @param closure the configuration of the JAR file

		t.Fatalf("part.1 not healed correctly")
	}

	// Test 2, Corrupt part.1
	err = firstDisk.WriteAll(context.Background(), bucket, pathJoin(object, fi.DataDir, "part.1"), []byte("foobytes"))
	if err != nil {
		t.Fatalf("Failed to write a file - %v", err)
	}

	_, err = objLayer.HealObject(ctx, bucket, object, "", madmin.HealOpts{ScanMode: madmin.HealNormalScan})
	if err != nil {

        return fromBytes(bytes, serializer)
    }

    <T> T fromBytes(byte[] bytes, Serializer<T> serializer) {
        return serializer.read(getDecoder().newInstance(new ByteArrayInputStream(bytes)))
    }

    <T> byte[] toBytes(T value, Serializer<T> serializer) {
        def bytes = new ByteArrayOutputStream()
        def encoder = getEncoder().newInstance(bytes)
        serializer.write(encoder, value)

    public <T> T serialize(T value, Serializer<T> serializer) {
        def bytes = toBytes(value, serializer)
        return fromBytes(bytes, serializer)
    }

    public <T> T fromBytes(byte[] bytes, Serializer<T> serializer) {
        return serializer.read(new KryoBackedDecoder(new ByteArrayInputStream(bytes)))
    }

    public <T> byte[] toBytes(T value, Serializer<T> serializer) {
        def bytes = new ByteArrayOutputStream()

    }

    def "won't parse too short bytes: #length"() {
        when:
        HashCode.fromBytes(toBytes([0x12] * length))

        then:
        thrown Exception

        where:
        length << [0, 1, 2, 3]
    }

    def "won't parse too long bytes"() {
        when:
        HashCode.fromBytes(toBytes([0x12] * 256))

        then:
        thrown Exception
    }

        registry.register(Integer, intSerializer)
        registry.register(Long, longSerializer)
        def serializer2 = registry.build(Number)

        expect:
        fromBytes(toBytes(123L, serializer1), serializer2) == 123L
        fromBytes(toBytes(123, serializer1), serializer2) == 123
    }

    def "cannot write value with type that has not been registered"() {
        given:

    }

    def "multiple writes of the same custom reason"() {
        when:
        def single = toBytes(withReason("hello"), serializer)
        def withDuplicate = toBytes(withReasons("hello", "hello"), serializer)
        def withoutDuplicate = toBytes(withReasons("hello", "other"), serializer)

        then:
        single.length < withDuplicate.length
        withDuplicate.length < 2*single.length

    }

    def "uses efficient serialization for Paths"() {
        expect:
        def serializer = factory.getSerializerFor(Path)
        def encoded = toBytes(Paths.get("some-file"), serializer)
        fromBytes(encoded, serializer) == Paths.get("some-file")
        encoded.length == 10
    }

    def "uses efficient serialization for Long"() {
        expect:

			"--package-name", "fiat", "--no-prefix-fiat", c.Prefix, "64", c.Prime,
			"mul", "square", "add", "sub", "one", "from_montgomery", "to_montgomery",
			"selectznz", "to_bytes", "from_bytes")
		cmd.Stderr = os.Stderr
		out, err := cmd.Output()
		if err != nil {
			log.Fatal(err)
		}
		out, err = format.Source(out)
		if err != nil {
			log.Fatal(err)
		}

func FromNull() *Value {
	return &Value{value: nil}
}

// FromMissing creates a Value with Missing value
func FromMissing() *Value {
	return &Value{value: Missing{}}
}

// FromBytes creates a Value from a []byte
func FromBytes(b []byte) *Value {
	return &Value{value: b}
}

// FromArray creates a Value from an array of values.
func FromArray(a []Value) *Value {
	return &Value{value: a}
}