if (byteCount > length) writeContinuationFrames(streamId, byteCount - length)
    }
  }

  @Throws(IOException::class)
  fun flush() {
    this.withLock {
      if (closed) throw IOException("closed")
      sink.flush()
    }
  }

  @Throws(IOException::class)
  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    this.withLock {

}

type rwUnwrapper interface {
	Unwrap() ResponseWriter
}

// Flush flushes buffered data to the client.
func (c *ResponseController) Flush() error {
	rw := c.rw
	for {
		switch t := rw.(type) {
		case interface{ FlushError() error }:
			return t.FlushError()
		case Flusher:
			t.Flush()
			return nil
		case rwUnwrapper:
			rw = t.Unwrap()
		default:
			return errNotSupported()

	w := &writerWithFlush{}
	fw := Wrap(w)
	for i := 0; i < 10; i++ {
		_, err := fw.Write([]byte("Test write"))
		if err != nil {
			t.Errorf("Unexpected error while writing with flush writer: %v", err)
		}
	}
	if w.flushCount != 10 {
		t.Errorf("Flush not called the expected number of times. Actual: %d", w.flushCount)
	}
	if w.writeCount != 10 {
		t.Errorf("Write not called the expected number of times. Actual: %d", w.writeCount)
	}

	// after adding an entry with the same key, previous indexes are correctly cleaned
	c.Add(secondEntry.Key(), secondEntry, req, res)

	assert.Equal(t, cache.store.Len(), 1)

	// Flush the cache and validate the index is cleaned.
	cache.Flush()
	assert.Equal(t, cache.indexLength(), 1)

	assert.Equal(t, cache.configIndexSnapshot(), map[ConfigHash]sets.Set[uint64]{

    def "can encode and decode an empty stream"() {
        def outputStream = new ByteArrayOutputStream()
        def encoder = new EncodedStream.EncodedOutput(outputStream)

        when:
        encoder.flush()

        then:
        def inputStream = new ByteArrayInputStream(outputStream.toByteArray())
        def decoder = new EncodedStream.EncodedInput(inputStream)
        decoder.read() < 0
    }

        cacheAccessWorker.flush()

        then:
        counter == 3

        cleanup:
        cacheAccessWorker?.stop()
    }

    def "flush rethrows action failure"() {
        def failure = new RuntimeException()
        cacheAccessWorker.enqueue { throw failure }

        when:
        start(cacheAccessWorker)
        cacheAccessWorker.flush()

        then:

        renderer.onOutput(event('info', LogLevel.INFO, 1L))
        renderer.onOutput(event('error', LogLevel.ERROR, 1L))
        renderer.onOutput(complete('status'))
        renderer.restore(snapshot) // close console to flush

        then:
        console.buildOutputArea.toString().readLines() == ['', '{header}> description{info} status{normal}', 'info', '{error}error', '{normal}']
        outputs.stdOut == ''
        outputs.stdErr == ''

        then:
        1 * target.execute(listener)
        1 * loggingOutput.flush()
        0 * _._
    }

    def "reports exception thrown by Action"() {
        def failure = new RuntimeException()

        when:
        action.execute(listener)

        then:
        1 * target.execute(listener) >> { throw failure }
        1 * loggingOutput.flush()
        1 * reporter.execute(failure)

	if len(contentType) == 0 {
		contentType = resp.Header.Get("Content-Type")
		if len(contentType) > 0 {
			contentType = strings.TrimSpace(strings.SplitN(contentType, ";", 2)[0])
		}
	}
	flush = s.Flush
	stream = resp.Body
	return
}

// PreventRedirects is a redirect checker that prevents the client from following a redirect.
func PreventRedirects(_ *http.Request, _ []*http.Request) error {

	FF1                           = 0x2000
	FFDLY                         = 0x2000
	FLUSHBAND                     = 0x40
	FLUSHLOW                      = 0x8
	FLUSHO                        = 0x100000
	FLUSHR                        = 0x1
	FLUSHRW                       = 0x3
	FLUSHW                        = 0x2
	F_CLOSEM                      = 0xa
	F_DUP2FD                      = 0xe
	F_DUPFD                       = 0x0