}

type fakeExitError struct {
	exited     bool
	statusCode int
}

func (f *fakeExitError) String() string {
	return f.Error()
}

func (f *fakeExitError) Error() string {
	return "fake exit"
}

func (f *fakeExitError) Exited() bool {
	return f.exited
}

func (f *fakeExitError) ExitStatus() int {
	return f.statusCode
}

func TestExec(t *testing.T) {
	prober := New()

						return false, nil
					}

					defer func() {
						_ = resp.Body.Close()
					}()
					if resp.StatusCode != http.StatusOK {
						lastError = errors.Errorf("%s /healthz check failed with status: %d", comp.name, resp.StatusCode)
						return false, nil
					}

					return true, nil
				})
			if err != nil {

          flib_.get(), &control_ret_node_names_, &control_rets_updated_),
      Status(absl::StatusCode::kAborted, "aborted"));
  verifyGraph(original_graph_def);
  verifyCounters();
}

TEST_F(MlirGraphOptimizationPassTest, OptimizationPassFailsDisabledFallback) {
  Init(Status(absl::StatusCode::kAborted, "aborted"),
       {MlirOptimizationPassState::Disabled,
        MlirOptimizationPassState::FallbackEnabled});

	if err != nil {
		return
	}

	// Only display response header.
	var respTrace []byte

	// For errors we make sure to dump response body as well.
	if resp.StatusCode != http.StatusOK &&
		resp.StatusCode != http.StatusPartialContent &&
		resp.StatusCode != http.StatusNoContent {
		respTrace, err = httputil.DumpResponse(resp, true)
		if err != nil {
			return
		}
	} else {

	resp, err := http.Get(httpURL)
	if err != nil {
		t.Fatalf("Got error GETing: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode != expectedErrorCode {
		t.Errorf("expected status code %d, got %d", expectedErrorCode, resp.StatusCode)
	}
}

// Ensure all registered handlers & services have an associated testcase.
func TestAuthzCoverage(t *testing.T) {
	fw := newServerTest()

		size := rand.Intn(128 << 10)
		res, err := http.Get(fmt.Sprintf("%s/?size=%d", ts.URL, size))
		if err != nil {
			log.Fatalf("stressNet: http Get error: %v", err)
		}
		if res.StatusCode != 200 {
			log.Fatalf("stressNet: Status code = %d", res.StatusCode)
		}
		n, err := io.Copy(io.Discard, res.Body)
		if err != nil {
			log.Fatalf("stressNet: io.Copy: %v", err)
		}
		if n != int64(size) {

TEST(MetricsTest, TestInvalidMakePathAndSingleprint) {
  EXPECT_THAT(MakeSavedModelPathAndSingleprint("", "singleprint"),
              testing::StatusIs(absl::StatusCode::kInvalidArgument));
  EXPECT_THAT(MakeSavedModelPathAndSingleprint("path", ""),
              testing::StatusIs(absl::StatusCode::kInvalidArgument));
}

TEST(MetricsTest, TestReadFingerprint) {
  EXPECT_EQ(SavedModelReadFingerprint().value(), "");

!!! warning "Achtung"
    Beachten Sie, dass diese Parameter direkt dem *Pfadoperation-Dekorator* übergeben werden, nicht der *Pfadoperation-Funktion*.

## Response-Statuscode

Sie können den (HTTP-)`status_code` definieren, den die Response Ihrer *Pfadoperation* verwenden soll.

Sie können direkt den `int`-Code übergeben, etwa `404`.

    private boolean noFollow = false;

    public int getHttpStatusCode() {
        return httpStatusCode;
    }

    public void setHttpStatusCode(final int statusCode) {
        httpStatusCode = statusCode;
    }

    public boolean hasResponseBody() {
        return responseBodyBytes != null || responseBodyFile != null;
    }

    public InputStream getResponseBody() {

      if (!port::kLittleEndian) {
        TF_RETURN_IF_ERROR(ByteSwapTensorContentInMetaGraphDef(meta_graph_def));
      }
      return meta_graph_def;
    }
  }
  return Status(
      absl::StatusCode::kNotFound,
      strings::StrCat(
          "Could not find meta graph def matching supplied tags: { ",
          absl::StrJoin(tags, " "),
          " }. To inspect available tag-sets in the SavedModel, please "