when:
        encodeTo(outputStream) { Encoder encoder ->
            encoder.outputStream.flush()
            encoder.outputStream.close()
        }

        then:
        0 * outputStream.close()
        0 * outputStream.flush()
    }

    def "can encode and decode raw bytes"() {
        expect:
        def bytes = encode { Encoder encoder ->
            encoder.writeByte(Byte.MIN_VALUE)

 */

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) {

      super(message);
    }
  }

  /** Encodes the specified byte array, and returns the encoded {@code String}. */
  public String encode(byte[] bytes) {
    return encode(bytes, 0, bytes.length);
  }

  /**
   * Encodes the specified range of the specified byte array, and returns the encoded {@code
   * String}.
   */
  public final String encode(byte[] bytes, int off, int len) {

      super(message);
    }
  }

  /** Encodes the specified byte array, and returns the encoded {@code String}. */
  public String encode(byte[] bytes) {
    return encode(bytes, 0, bytes.length);
  }

  /**
   * Encodes the specified range of the specified byte array, and returns the encoded {@code
   * String}.
   */
  public final String encode(byte[] bytes, int off, int len) {

        }
    }

    def "can encode and decode multiple byte streams"() {
        when:
        def bytes = encode { Encoder encoder ->
            encoder.encodeChunked { Encoder nested ->
                nested.writeSmallInt(1)
                nested.writeString("chunked")
            }
            encoder.encodeChunked { Encoder nested ->
            }
            encoder.encodeChunked { Encoder nested ->

    if isinstance(obj, BaseModel):
        # TODO: remove when deprecating Pydantic v1
        encoders: Dict[Any, Any] = {}
        if not PYDANTIC_V2:
            encoders = getattr(obj.__config__, "json_encoders", {})  # type: ignore[attr-defined]
            if custom_encoder:
                encoders.update(custom_encoder)
        obj_dict = _model_dump(
            obj,
            mode="json",

    /**
     * Writes the given byte array to the stream. Encodes the bytes and length information.
     */
    void writeBinary(byte[] bytes, int offset, int count) throws IOException;

    /**
     * Appends an encoded stream to this stream. Encodes the stream as a series of chunks with length information.
     */
    void encodeChunked(EncodeAction<Encoder> writeAction) throws Exception;

    /**

func (w *Encoder) Uint64(x uint64) {
	w.Sync(SyncUint64)
	w.rawUvarint(x)
}

// Len encodes and writes a non-negative int value into the element bitstream.
func (w *Encoder) Len(x int) { assert(x >= 0); w.Uint64(uint64(x)) }

// Int encodes and writes an int value into the element bitstream.
func (w *Encoder) Int(x int) { w.Int64(int64(x)) }

// Len encodes and writes a uint value into the element bitstream.

// by calling [Encoder.SetEscapeHTML](false).
//
// Array and slice values encode as JSON arrays, except that
// []byte encodes as a base64-encoded string, and a nil slice
// encodes as the null JSON value.
//
// Struct values encode as JSON objects.
// Each exported struct field becomes a member of the object, using the
// field name as the object key, unless the field is omitted for one of the

	enc := new(Encoder)
	enc.w = []io.Writer{w}
	enc.sent = make(map[reflect.Type]typeId)
	enc.countState = enc.newEncoderState(new(encBuffer))
	return enc
}

// writer returns the innermost writer the encoder is using.
func (enc *Encoder) writer() io.Writer {
	return enc.w[len(enc.w)-1]
}

// pushWriter adds a writer to the encoder.
func (enc *Encoder) pushWriter(w io.Writer) {
	enc.w = append(enc.w, w)
}