i, err = d.object()
		}
		return i, Object, err
	default:
		return nil, Unknown, d.mkError(ErrSyntax, "looking for beginning of value")
	}
}

// string called by `any` or `object`(for map keys) after reading `"`
func (d *Decoder) string() (string, error) {
	d.scratch.reset()
	c := d.next()

scan:
	for {
		switch {
		case c == '"':
			return string(d.scratch.bytes()), nil
		case c == '\\':

            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));
            result.setPermissions(toStringArray(source.get("permissions")));
            result.setReading(DfTypeUtil.toString(source.get("reading")));
            result.setSuggestWord(DfTypeUtil.toString(source.get("suggestWord")));
            result.setUpdatedBy(DfTypeUtil.toString(source.get("updatedBy")));

    public fun onRequestStart(socketEffect: SocketEffect?): Builder =
      apply {
        this.onRequestStart = socketEffect
      }

    /**
     * Process the response without even attempting to reading the request body. For HTTP/2 this
     * will close the response stream after the response body or trailers. For HTTP/1 this will
     * close the socket after the response body or trailers.
     */

      "timeout",
      "Read timed out",
    )
    assertThat(webSocket.close(1000, null)).isFalse()
  }

  /**
   * There's no read timeout when reading the first byte of a new frame. But as soon as we start
   * reading a frame we enable the read timeout. In this test we have the server returning the first
   * byte of a frame but no more frames.
   */
  @Test
  fun readTimeoutAppliesWithinFrames() {

    private static final Logger logger = LogManager.getLogger(ESSourceReader.class);

    /** Queue of documents. */
    protected final Queue<Map<String, Object>> queue = new ConcurrentLinkedQueue<>();
    /** Flag indicating if reading is finished. */
    protected final AtomicBoolean isFinished = new AtomicBoolean(false);

    /** OpenSearch client. */
    protected final Client client;
    /** Suggest settings. */

	resp := rw.Result()
	if resp.StatusCode != 123 {
		t.Fatalf("unexpected status: %v", resp.StatusCode)
	}
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		t.Fatalf("reading response body failed: %v", err)
	}
	if string(body) != "hello" {
		t.Fatalf("response body incorrect: %v", string(body))
	}

	// Check that Unwrap works
	if trw.Unwrap() != rw {

    }

    // --- as(Class, ASN1InputStream) ---

    @Test
    void testAs_ASN1InputStream_Success() throws IOException, PACDecodingException {
        // Test successful reading and casting from ASN1InputStream
        ASN1Integer original = new ASN1Integer(456);
        ByteArrayInputStream bais = new ByteArrayInputStream(original.getEncoded());
        ASN1InputStream ais = new ASN1InputStream(bais);

  }

  private static final class JavaIoCreator extends TempFileCreator {
    @Override
    File createTempDir() {
      File baseDir = new File(JAVA_IO_TMPDIR.value());
      @SuppressWarnings("GoodTime") // reading system time without TimeSource
      String baseName = System.currentTimeMillis() + "-";

      for (int counter = 0; counter < TEMP_DIR_ATTEMPTS; counter++) {
        File tempDir = new File(baseDir, baseName + counter);

    val promisedStreamId = source.readInt() and 0x7fffffff
    val headerBlockLength = lengthWithoutPadding(length - 4, flags, padding) // - 4 for readInt().
    val headerBlock = readHeaderBlock(headerBlockLength, padding, flags, streamId)
    handler.pushPromise(streamId, promisedStreamId, headerBlock)
  }

  @Throws(IOException::class)
  private fun readPing(
    handler: Handler,
    length: Int,

	workers    atomic.Int64
	maxWorkers int64

	// workerStartMu sync.Mutex
	lastStarted time.Time

	wg sync.WaitGroup

	// Channel of log entries.
	// Reading logCh must hold read lock on logChMu (to avoid read race)
	// Sending a value on logCh must hold read lock on logChMu (to avoid closing)
	logCh   chan any
	logChMu sync.RWMutex

	// If this webhook is being re-configured we will