import java.io.Closeable;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class OutputStreamBackedEncoder extends AbstractEncoder implements Closeable, FlushableEncoder {
    private final DataOutputStream outputStream;

    public OutputStreamBackedEncoder(OutputStream outputStream) {
        this.outputStream = new DataOutputStream(outputStream);
    }

    @Override

            }
            chmod.chmod(cacheFile.getParentFile(), 0700); // read-write-execute for user only
            chmod.chmod(cacheFile, 0600); // read-write for user only
            OutputStreamBackedEncoder encoder = new OutputStreamBackedEncoder(new BufferedOutputStream(new FileOutputStream(cacheFile)));
            try {
                serializer.write(encoder, newValue);
            } finally {
                encoder.close();

            new TestAction("value"),
            NativeServicesMode.ENABLED
        )

        when:
        ByteArrayOutputStream baos = new ByteArrayOutputStream()
        OutputStreamBackedEncoder encoder = new OutputStreamBackedEncoder(baos)
        new WorkerConfigSerializer().write(encoder, original)

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray())

import org.gradle.internal.resolve.ModuleVersionResolveException
import org.gradle.internal.serialize.InputStreamBackedDecoder
import org.gradle.internal.serialize.OutputStreamBackedEncoder
import spock.lang.Specification

import static org.gradle.api.internal.artifacts.DefaultModuleVersionSelector.newSelector

class DependencyResultSerializerTest extends Specification {

        });
    }

    @Override
    public void put(K key, V value) {
        ByteArrayOutputStream outstr = new ByteArrayOutputStream();
        OutputStreamBackedEncoder encoder = new OutputStreamBackedEncoder(outstr);
        try {
            valueSerializer.write(encoder, value);
            encoder.flush();
        } catch (Exception e) {

import org.gradle.internal.serialize.InputStreamBackedDecoder
import org.gradle.internal.serialize.OutputStreamBackedEncoder

class DummyBinaryStore implements BinaryStore {

    private final ByteArrayOutputStream bytes = new ByteArrayOutputStream()
    private Encoder output = new OutputStreamBackedEncoder(bytes)

    void write(WriteAction write) {
        write.write(output)
    }

    BinaryData done() {

package org.gradle.internal.serialize

class StreamBackedCodecTest extends AbstractCodecTest {
    @Override
    void encodeTo(OutputStream outputStream, Closure<Encoder> closure) {
        def encoder = new OutputStreamBackedEncoder(outputStream)
        closure.call(encoder)
    }

    @Override
    void decodeFrom(InputStream inputStream, Closure<Decoder> closure) {
        def decoder = new InputStreamBackedDecoder(inputStream)

import org.gradle.internal.hash.HashCode
import org.gradle.internal.hash.TestHashCodes
import org.gradle.internal.serialize.InputStreamBackedDecoder
import org.gradle.internal.serialize.OutputStreamBackedEncoder
import spock.lang.Specification
import spock.lang.Subject

import static org.gradle.api.internal.tasks.compile.incremental.compilerapi.deps.DependentsSet.dependencyToAll

                processBuilder.getNativeServicesMode()
            );

            // Serialize the worker config, this is consumed by SystemApplicationClassLoaderWorker
            OutputStreamBackedEncoder encoder = new OutputStreamBackedEncoder(outstr);
            try {
                new WorkerConfigSerializer().write(encoder, config);
            } finally {
                encoder.flush();
            }

import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.FlushableEncoder;
import org.gradle.internal.serialize.InputStreamBackedDecoder;
import org.gradle.internal.serialize.OutputStreamBackedEncoder;
import org.gradle.internal.stream.EncodedStream;
import org.gradle.launcher.daemon.diagnostics.DaemonDiagnostics;
import org.gradle.launcher.daemon.diagnostics.DaemonStartupInfo;