origReallyCrash := runtime.ReallyCrash
	runtime.ReallyCrash = false
	defer func() {
		runtime.ReallyCrash = origReallyCrash
	}()

	sendResponse := make(chan string, 1)
	doPanic := make(chan interface{}, 1)
	writeErrors := make(chan error, 1)
	gotPanic := make(chan interface{}, 1)
	timeout := make(chan time.Time, 1)
	resp := "test response"
	timeoutErr := apierrors.NewServerTimeout(schema.GroupResource{Group: "foo", Resource: "bar"}, "get", 0)

    }

    private void writeConfiguration(ReportConfiguration config) {
        writeConfigurationNameHeader(config, spec.getReportedTypeAlias());
        writeDescription(config.getDescription());

        writeErrors(config.getLenientErrors());

        if (!config.getAttributes().isEmpty() ||
            (spec.isIncludeCapabilities() && !config.getCapabilities().isEmpty()) ||

func testTimeoutHandler(t *testing.T, mode testMode) {
	sendHi := make(chan bool, 1)
	writeErrors := make(chan error, 1)
	sayHi := HandlerFunc(func(w ResponseWriter, r *Request) {
		<-sendHi
		_, werr := w.Write([]byte("hi"))
		writeErrors <- werr
	})
	ctx, cancel := context.WithCancel(context.Background())
	h := NewTestTimeoutHandler(sayHi, cancelableTimeoutContext{ctx})

	if err != nil {
		utilruntime.HandleError(err)
		response.WriteError(http.StatusBadRequest, err)
		return
	}
	pod, ok := s.host.GetPodByName(params.podNamespace, params.podName)
	if !ok {
		response.WriteError(http.StatusNotFound, fmt.Errorf("pod does not exist"))
		return
	}
	if len(params.podUID) > 0 && pod.UID != params.podUID {
		response.WriteError(http.StatusNotFound, fmt.Errorf("pod not found"))
		return
	}

	p := dumper{
		output: w,
		ptrmap: make(map[Node]int),
		last:   '\n', // force printing of line number on first line
	}

	defer func() {
		if e := recover(); e != nil {
			err = e.(writeError).err // re-panics if it's not a writeError
		}
	}()

	if n == nil {
		p.printf("nil\n")
		return
	}
	p.dump(reflect.ValueOf(n), n)
	p.printf("\n")

	return
}

type dumper struct {
	output io.Writer

	} else {
		h.echo(w, r, id)
	}
}

// nolint: interfacer
func writeError(out *bytes.Buffer, msg string) {
	epLog.Warn(msg)
	_, _ = out.WriteString(msg + "\n")
}

func (h *httpHandler) echo(w http.ResponseWriter, r *http.Request, id uuid.UUID) {
	body := bytes.Buffer{}

	if err := r.ParseForm(); err != nil {
		writeError(&body, "ParseForm() error: "+err.Error())
	}

                property("documentationLink", documentationLinkFor(it))
            }
            details.failure?.let { failure ->
                comma()
                writeError(failure)
            }
        }
    }

    private
    fun writeError(failure: DecoratedFailure) {
        val summary = failure.summary
        val parts = failure.parts
        property("error") {
            jsonObject {

	f.WriteForRequest(out, requestID, key+":"+value)
}

func WriteBodyLine(out io.StringWriter, requestID int, line string) {
	_, _ = out.WriteString(fmt.Sprintf("[%d body] %s\n", requestID, line))
}

func WriteError(out io.StringWriter, requestID int, err error) {
	_, _ = out.WriteString(fmt.Sprintf("[%d error] %v\n", requestID, err))
}

const (
	RequestIDField        Field = "X-Request-Id"

	})
}

// writeError is the wrapper type used internally when Execute has an
// error writing to its output. We strip the wrapper in errRecover.
// Note that this is not an implementation of error, so it cannot escape
// from the package as an error value.
type writeError struct {
	Err error // Original error.
}

func (s *state) writeError(err error) {
	panic(writeError{
		Err: err,
	})

// request is provided for logging.
func handleError(response *restful.Response, request string, err error) {
	switch err {
	case kubecontainer.ErrContainerNotFound:
		response.WriteError(http.StatusNotFound, err)
	default:
		msg := fmt.Sprintf("Internal Error: %v", err)
		klog.ErrorS(err, "HTTP InternalServerError serving", "request", request)
		response.WriteErrorString(http.StatusInternalServerError, msg)