when:
        serializer.write(encoder, spec)
        encoder.flush()

        and:
        def decoder = new KryoBackedDecoder(new ByteArrayInputStream(outputStream.toByteArray()))
        def decodedSpec = serializer.read(decoder)

        then:
        decodedSpec == spec
    }

        when:
        serializer.write(encoder, classLoaderStructure)
        encoder.flush()

        and:
        def decoder = new KryoBackedDecoder(new ByteArrayInputStream(outputStream.toByteArray()))
        def decodedClassloaderStructure = serializer.read(decoder)

        then:
        decodedClassloaderStructure == classLoaderStructure
    }

        URLConnection connection = Mock()
        URL url = new URL("custom", "host", 12, "file", handler)
        _ * handler.openConnection(url) >> connection
        _ * connection.getInputStream() >> new ByteArrayInputStream(contents)
        url
    }

    interface ServiceType {
        ServiceDependency getDependency()
    }

    interface ServiceDependency {
    }

        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)

            names.each {
                serializer.write(encoder, it)
            }
        }
        def bytes = out.toByteArray()
        def decoder = new KryoBackedDecoder(new ByteArrayInputStream(bytes))
        def result = []
        names.each {
            result << deserializer.read(decoder)
        }

        then:
        result == names

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.helper;

import static org.codelibs.core.stream.StreamUtil.split;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Proxy;
import java.nio.file.Files;
import java.nio.file.Path;

        assertArgumentNotNull("contents", contents);

        if (encoding == null) {
            return new ByteArrayInputStream(contents.getBytes());
        }
        try {
            return new ByteArrayInputStream(contents.getBytes(encoding));
        } catch (final UnsupportedEncodingException ex) {
            throw new IORuntimeException(ex);
        }
    }

    /**

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.pac.kerberos;


import java.io.ByteArrayInputStream;
import java.io.IOException;

import javax.security.auth.kerberos.KerberosKey;

import org.bouncycastle.asn1.*;

import jcifs.pac.ASN1Util;
import jcifs.pac.PACDecodingException;

        URLConnection connection = Mock()
        URL url = new URL("custom", "host", 12, "file", handler)
        _ * handler.openConnection(url) >> connection
        _ * connection.getInputStream() >> new ByteArrayInputStream(contents)
        url
    }

    }

    static InputStream inputStream(String content) {
        return inputStream(content.bytes)
    }

    static InputStream inputStream(byte[] bytes) {
        return new ByteArrayInputStream(bytes)
    }