} catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    private void generate(String packageName, String className, ProjectDescriptor current) throws IOException {
        writeHeader(packageName);
        writeLn("@NonNullApi");
        writeLn("public class " + className + " extends TypeSafeProjectDependencyFactory {\n");
        writeLn();
        writeLn("    @Inject");

// it is used for testing purpose only
type FakeResponseWriter struct{}

func (fw *FakeResponseWriter) Header() http.Header          { return http.Header{} }
func (fw *FakeResponseWriter) WriteHeader(code int)         {}
func (fw *FakeResponseWriter) Write(bs []byte) (int, error) { return len(bs), nil }

// For HTTP2 an http.ResponseWriter object implements
// http.Flusher and http.CloseNotifier.

			if httpServerEventCount < len(httpHealthStatuses) && httpHealthStatuses[httpServerEventCount] {
				writer.WriteHeader(http.StatusOK)
				writer.Write([]byte("foobar"))
			} else {
				writer.WriteHeader(http.StatusInternalServerError)
			}
			httpServerEventCount++
		}))
		host, ports, err := net.SplitHostPort(strings.TrimPrefix(sss.URL, "http://"))
		if err != nil {

        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
        return this;
    }

    public void generate(DefaultVersionCatalog model) {
        writeHeader();
        writeMetadata();
        writeVersions(model);
        writeLibraries(model);
        writeBundles(model);
        writePlugins(model);
    }

   */
  var sourceCount = 0

  val isClosed: Boolean
    get() = file == null

  @Throws(IOException::class)
  private fun writeHeader(
    prefix: ByteString,
    upstreamSize: Long,
    metadataSize: Long,
  ) {
    val header =
      Buffer().apply {
        write(prefix)
        writeLong(upstreamSize)
        writeLong(metadataSize)

	return denyH2cUpgrade(h2c.NewHandler(h, s))
}

func denyH2cUpgrade(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if isH2CUpgrade(r.Header) {
			w.WriteHeader(http.StatusMethodNotAllowed)
			_, _ = w.Write([]byte("h2c upgrade not allowed"))
			return
		}
		h.ServeHTTP(w, r)
	})
}

func isH2CUpgrade(h http.Header) bool {

type testResponseWriter struct {
	h           http.Header
	writeHeader func(int)
	write       func([]byte) (int, error)
}

func (rw *testResponseWriter) Header() http.Header {
	if rw.h == nil {
		rw.h = make(http.Header)
	}
	return rw.h
}

func (rw *testResponseWriter) WriteHeader(statusCode int) {
	if rw.writeHeader != nil {
		rw.writeHeader(statusCode)
	}
}

	assert.True(t, errors.Is(err, http.ErrHijacked), "Hijacked error returned if writing after hijacked")
	// Validate WriteHeader().
	trw = &tunnelingResponseWriter{w: &mockResponseWriter{}}
	expectedStatusCode := 201
	assert.False(t, trw.written, "Written field originally false in delegate response writer")
	trw.WriteHeader(expectedStatusCode)

			defer func() { <-pool }()
			globalHTTPStats.addRequestsInQueue(-1)
			if contextCanceled(ctx) {
				w.WriteHeader(499)
				return
			}
			f.ServeHTTP(w, r)
		case <-deadlineTimer.C:
			globalHTTPStats.addRequestsInQueue(-1)
			if contextCanceled(ctx) {
				w.WriteHeader(499)
				return
			}
			// Send a http timeout message
			writeErrorResponse(ctx, w,

	watchHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		timer := time.NewTicker(time.Second)
		defer timer.Stop()

		w.Header().Set("Transfer-Encoding", "chunked")
		w.WriteHeader(200)

		flusher, _ := w.(http.Flusher)
		flusher.Flush()

		count := 0
		for {
			<-timer.C
			n, err := w.Write(responseBody[count : count+1])
			if err != nil {
				return
			}