"/items/", headers={"X-Token": "fake-super-secret-token", "X-Key": "invalid"}
    )
    assert response.status_code == 400, response.text
    assert response.json() == {"detail": "X-Key header invalid"}


def test_get_valid_headers():
    response = client.get(
        "/items/",
        headers={
            "X-Token": "fake-super-secret-token",
            "X-Key": "fake-super-secret-key",
        },
    )

        "/items/", headers={"X-Token": "fake-super-secret-token", "X-Key": "invalid"}
    )
    assert response.status_code == 400, response.text
    assert response.json() == {"detail": "X-Key header invalid"}


@needs_py39
def test_get_valid_headers(client: TestClient):
    response = client.get(
        "/items/",
        headers={
            "X-Token": "fake-super-secret-token",

     * for [this]. Otherwise, returns `null`.
     */
    @KaAnalysisApiInternals
    public fun KtDeclaration.getOriginalDeclaration(): KtDeclaration? =
        withValidityAssertion { analysisSession.originalPsiProvider.getOriginalDeclaration(this) }

    /**

// CHECK:           return %[[VAL_2]] : tuple<tensor<3x4xf32>>
// CHECK:         }
func.func @tfl_wrapped_jax_random_normal(%arg0: tensor<2xui32>) -> tuple<tensor<3x4xf32>> {
  // This is a fake jax random normal body.
  %0 = stablehlo.constant dense<0.0> : tensor<12xf32>
  %1 = "stablehlo.reshape"(%0) : (tensor<12xf32>) -> tensor<3x4xf32>
  %2 = "stablehlo.tuple"(%1) : (tensor<3x4xf32>) -> tuple<tensor<3x4xf32>>

			pod.Spec.ServiceAccountName = "testsan"
			pod.Labels = c.podLabels
			pod.Spec.NodeName = "fake"
			// All should get this
			c.expected[labelutil.LabelHostname] = "fake"

			loc := pkgmodel.ConvertLocality(c.ctl.locality)
			fc := kube.NewFakeClient(&v1.Node{
				ObjectMeta: metav1.ObjectMeta{Name: "fake", Labels: map[string]string{
					NodeRegionLabelGA:          loc.Region,
					NodeZoneLabel:              loc.Zone,

	for i, test := range tests {
		featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.ExecProbeTimeout, test.execProbeTimeout)
		fake := FakeCmd{
			out: []byte(test.output),
			err: test.err,
		}
		status, output, err := prober.Probe(&fake)
		if status != test.expectedStatus {
			t.Errorf("[%d] expected %v, got %v", i, test.expectedStatus, status)
		}
		if err != nil && !test.expectError {

		clock:            clock.RealClock{},
		kubeClient:       &fake.Clientset{},
		hostname:         testKubeletHostname,
		nodeName:         testKubeletHostname,
		runtimeState:     newRuntimeState(time.Second),
		hostutil:         hostutil.NewFakeHostUtil(nil),
	}
	kb.containerManager = cm.NewStubContainerManager()

	plug := &volumetest.FakeVolumePlugin{PluginName: "fake", Host: nil}
	kb.volumePluginMgr, err =

	"istio.io/istio/pilot/pkg/server"
	"istio.io/istio/pkg/test"
)

func TestStartWithError(t *testing.T) {
	g := NewWithT(t)

	inst := server.New()
	expected := errors.New("fake")
	inst.RunComponent("fake", func(stop <-chan struct{}) error {
		return expected
	})

	stop := newReclosableChannel()
	t.Cleanup(stop.Close)
	g.Expect(inst.Start(stop.c)).To(Equal(expected))
}

			}

			client := fake.NewSimpleClientset()
			if !tc.remoteCluster {
				client.PrependReactor("create", "tokenreviews", func(action ktesting.Action) (bool, runtime.Object, error) {
					return true, tokenReview, nil
				})
			}

			remoteKubeClientGetter := func(clusterID cluster.ID) kubernetes.Interface {
				if clusterID == remoteCluster {
					client := fake.NewSimpleClientset()
					if tc.remoteCluster {

metadata:
  name: hello
spec:
  selector:
    matchLabels:
      app: hello
  template:
    metadata:
      labels:
        app: hello
    spec:
      containers:
      - name: hello
        image: "fake.docker.io/google-samples/hello-go-gke:1.0"
      - name: istio-proxy
        image: auto
        securityContext:
          # iptables rules must honor this value, and must not use 1337
          runAsUser: 1234