*/

package metrics

import (
	"context"
	"sync"

	"k8s.io/component-base/metrics"
	"k8s.io/component-base/metrics/legacyregistry"
)

const (
	subsystem  = "apiserver"
	statuscode = "code"
)

var registerMetricsOnce sync.Once

var (
	// streamTranslatorRequestsTotal counts the number of requests that were handled by
	// the StreamTranslatorProxy.

								ingressutil.ExpectedResponse{StatusCode: http.StatusOK})
						})
						t.NewSubTest("request with client certificates").Run(func(t framework.TestContext) {
							// Send a TLS request with client certificates.
							ingressutil.SendRequestOrFail(t, ing, host, credName, ingressutil.Mtls, tlsContext,
								ingressutil.ExpectedResponse{StatusCode: http.StatusOK})
						})
					})
			}
		})
}

		return false
	}
	// hope for a 200, remove file on a 4xx, otherwise it will be retried by another process
	if resp.StatusCode != 200 {
		u.logger.Printf("Failed to upload %s to %s: %s", filepath.Base(fname), endpoint, resp.Status)
		if resp.StatusCode >= 400 && resp.StatusCode < 500 {
			err := os.Remove(fname)
			if err == nil {
				u.logger.Printf("Removed local/%s", filepath.Base(fname))
			} else {

          break;
        default:
          return tensorflow::Status(absl::StatusCode::kInvalidArgument,
                                    "Unsupported type");
      }
    }
  } else {
    return tensorflow::Status(absl::StatusCode::kInvalidArgument,
                              "Unsupported type");
  }
}

// Returns a Constant op with a splat vector value.

	resp, err := http.DefaultClient.Post(reloadURL, "text/plain", nil)
	if err != nil {
		t.Fatalf("Run: %v", err)
	}
	if resp.StatusCode != http.StatusAccepted {
		t.Fatalf("Got unexpected status code: %v", resp.StatusCode)
	}
	select {
	case <-c:
	case <-time.After(5 * time.Second):
		t.Fatal("Timed out waiting for SIGUSR1")
	}
}

func startAndWaitForServer(t *testing.T) *Server {

  size_t op_names_size = enqueue_op_names_.size();
  if (op_names_size > kint32max) {
    return Status(absl::StatusCode::kInvalidArgument,
                  "Enqueue ops to run cannot exceed kint32max");
  }
  runs_ = static_cast<int>(op_names_size);
  if (runs_ == 0) {
    return Status(absl::StatusCode::kInvalidArgument,
                  "Empty enqueue ops to run.");
  }
  close_op_name_ = queue_runner_def.close_op_name();

					credentialToUse:  credNameGeneric,
					from:             apps.Ns1.A,
					drSelector:       "a",
					authorizeSidecar: true,
					expectedResponse: ingressutil.ExpectedResponse{
						StatusCode: http.StatusOK,
					},
				},
				// Mutual TLS origination from an unauthorized sidecar to https endpoint
				// This will result in a 503 with the UH flag because the cluster will

	t.Helper()
	res, err := http.Get(url + endpoint)
	if err != nil {
		t.Fatal(err)
	}
	defer res.Body.Close()
	if res.StatusCode != expectedStatusCode {
		t.Fatalf("expected status code from %s: %d, got: %d", endpoint, expectedStatusCode, res.StatusCode)
	}

        createHttpErrorStatusCodeException(401)
    }

    static RuntimeException createHttpErrorStatusCodeException(int statusCode) {
        createNestedException(new HttpErrorStatusCodeException('GET', 'test.file', statusCode, ''))
    }

    static RuntimeException createTimeoutException() {
        createNestedException(new InterruptedIOException('Read time out'))
    }

      /*saved_model_tags=*/{}, config,
      /*quantization_py_function_lib=*/nullptr, /*module_op=*/{});
  EXPECT_THAT(
      quantized_module_op,
      StatusIs(absl::StatusCode::kInvalidArgument,
               HasSubstr("`saved_model_bundle` should not be nullptr")));
}

TEST(RunQuantizationTest,
     WhenPyFunctionLibIsNullptrReturnsInvalidArgumentError) {