if !rl.statusRecorded {
		rl.recordStatus(http.StatusOK) // Default if WriteHeader hasn't been called
	}
	if rl.captureErrorOutput {
		rl.Addf("logging error output: %q\n", string(b))
	}
	return rl.w.Write(b)
}

// WriteHeader implements http.ResponseWriter.
func (rl *respLogger) WriteHeader(status int) {
	rl.recordStatus(status)
	rl.w.WriteHeader(status)
}

				header.Mode = 0o755
			} else {
				header.Mode = 0o644
			}
			header.Uid = 0
			header.Gid = 0

			// TODO: if we want reproducible builds we can fake the timestamps here

			if err := tw.WriteHeader(header); err != nil {
				return err
			}

			if info.Mode().IsRegular() {
				data, err := os.Open(src)
				if err != nil {
					return err
				}

				defer data.Close()

		// See RFC 1421, section 4.6.1.1
		if hasProcType {
			if err := writeHeader(out, procType, b.Headers[procType]); err != nil {
				return err
			}
		}
		// For consistency of output, write other headers sorted by key.
		slices.Sort(h)
		for _, k := range h {
			if err := writeHeader(out, k, b.Headers[k]); err != nil {
				return err
			}
		}
		if _, err := out.Write(nl); err != nil {

		defer cancel()

		err := s.db.PingContext(ctx)
		if err != nil {
			http.Error(w, fmt.Sprintf("db down: %v", err), http.StatusFailedDependency)
			return
		}
		w.WriteHeader(http.StatusOK)
		return
	case "/quick-action":
		// This is a short SELECT. Use the request context as the base of
		// the context timeout.
		ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)

        } 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 DelegatingProjectDependency {");
        writeLn();
        writeLn("    @Inject");

        } 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);
    }

	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 {