}

func (wr outerWithCloseNotifyAndFlush) Flush() {
	if flusher, ok := wr.UserProvidedDecorator.(http.Flusher); ok {
		flusher.Flush()
		return
	}

	wr.InnerCloseNotifierFlusher.Flush()
}

//lint:file-ignore SA1019 Keep supporting deprecated http.CloseNotifier
var _ http.CloseNotifier = outerWithCloseNotifyFlushAndHijack{}
var _ http.Flusher = outerWithCloseNotifyFlushAndHijack{}

import org.gradle.internal.logging.events.OutputEvent;
import org.gradle.internal.logging.events.OutputEventListener;
import org.gradle.internal.logging.events.UpdateNowEvent;

/**
 * Flushes the console output. Used when no other listener in the chain flushes the console.
 */
public class FlushConsoleListener implements OutputEventListener {
    private final OutputEventListener delegate;
    private final Console console;

	// the http.ResponseWriter object for both http/1.x and http2
	// implement http.Flusher and http.CloseNotifier
	if _, ok := w.(http.Flusher); !ok {
		t.Errorf("Expected the http.ResponseWriter object to implement http.Flusher")
	}

	//nolint:staticcheck // SA1019
	if _, ok := w.(http.CloseNotifier); !ok {

<!-- go.dev/issue/65319 -->
The runtime now explicitly flushes trace data when a program crashes due to an
uncaught panic. This means that more complete trace data will be available in a

	defer func() {
		if s.MemoryAllocator != nil {
			runtime.AllocatorPool.Put(s.MemoryAllocator)
		}
	}()

	flusher, ok := w.(http.Flusher)
	if !ok {
		err := fmt.Errorf("unable to start watch - can't get http.Flusher: %#v", w)
		utilruntime.HandleError(err)
		s.Scope.err(errors.NewInternalError(err), w, req)
		return
	}

	framer := s.Framer.NewFrameWriter(w)

// For HTTP2 an http.ResponseWriter object implements
// http.Flusher and http.CloseNotifier.
// It is used for testing purpose only
type FakeResponseWriterFlusherCloseNotifier struct {
	*FakeResponseWriter
}

func (fw *FakeResponseWriterFlusherCloseNotifier) Flush()                   {}
func (fw *FakeResponseWriterFlusherCloseNotifier) CloseNotify() <-chan bool { return nil }

			if err != nil {
				return
			}
			if len(mergeCh) == 0 {
				// Flush if nothing is queued
				w.(http.Flusher).Flush()
			}
			grid.PutByteBuffer(ev)
		case <-emptyEventTicker:
			if err := enc.Encode(struct{ Records []event.Event }{}); err != nil {
				return
			}
			w.(http.Flusher).Flush()
		case <-keepAliveTicker:
			if _, err := w.Write([]byte(" ")); err != nil {
				return
			}

    // TODO(ew): Consider whether this belongs in BuildProgressArea or here
    StyledLabel getStatusBar();

    /**
     * Flushes any pending updates. Updates may or may not be buffered, and this method should be called to finish rendering and pending updates, such as updating the status bar.
     */
    void flush();

		nr, err := src.Read(buf)
		log.Debugf("read %v/%v", nr, err)
		if nr > 0 { // before dealing with the read error
			nw, ew := dst.Write(buf[0:nr])
			log.Debugf("write %v/%v", nw, ew)
			if f, ok := dst.(http.Flusher); ok {
				f.Flush()
			}
			if nr != nw { // Should not happen
				ew = io.ErrShortWrite
			}
			if ew != nil {
				return
			}
		}
		if err != nil {
			// read is already closed - we need to close out

					return errors.New("header appeared from after WriteHeader")
				}
				return nil
			},
		},
		{
			name: "flush then write",
			handler: func(rw ResponseWriter, r *Request) {
				rw.(Flusher).Flush()
				rw.Write([]byte("post-flush"))
				rw.Header().Set("Too-Late", "Write already wrote headers")
			},
			check: func(got, logs string) error {