func TestRemoveContainers(t *testing.T) {
	for _, tc := range []struct {
		name        string
		containers  []string
		prepare     func(*fakeImpl)
		shouldError bool
	}{
		{
			name: "valid",
		},
		{
			name:        "valid: two containers",
			containers:  []string{"1", "2"},
			shouldError: false,
		},
		{
			name:       "invalid: remove pod sandbox fails",
			containers: []string{"1"},

			valid:       true,
		},
		{
			description: "valid name with namespace",
			name:        "testNamespace/testName",
			want:        "testNamespace/testName",
			valid:       true,
		},
	}
	for _, s := range steps {
		t.Run(s.description, func(tt *testing.T) {
			n, err := ParseFullName(s.name)
			if err == nil && n.String() != s.want {
				tt.Fatalf("unexpected name: %v", n)
			}
			if s.valid {

	if createErr == nil {
		t.Fatalf("Expected validation errors, but did not get one")
	}

	t.Logf("Checking that valid fields DO NOT show in error")
	for _, valid := range validListTypeFields {
		if strings.Contains(createErr.Error(), valid) {
			t.Errorf("unexpected error about %q: %v", valid, err)
		}
	}

	t.Logf("Checking that invalid fields DO show in error")
	for _, invalid := range invalidListTypeFields {

		t.testCreateIgnoresMismatchedNamespace(valid.DeepCopyObject(), dryRunOpts)
		t.testCreateIgnoresMismatchedNamespace(valid.DeepCopyObject(), opts)
		t.testCreateResetsUserData(valid.DeepCopyObject(), dryRunOpts)
		t.testCreateResetsUserData(valid.DeepCopyObject(), opts)
	} else {
		t.testCreateRejectsMismatchedNamespace(valid.DeepCopyObject(), dryRunOpts)

func IsHTTPURL(path string) (bool, error) {
	u, err := url.Parse(path)
	valid := err == nil && u.Host != "" && (u.Scheme == "http" || u.Scheme == "https")
	if strings.HasPrefix(path, "http") && !valid {
		return false, fmt.Errorf("%s starts with http but is not a valid URL: %s", path, err)
	}
	return valid, nil

			enableRatcheting: false,
			crd: &apiextensions.CustomResourceDefinition{
				ObjectMeta: metav1.ObjectMeta{Name: "foos.sigs.k8s.io", Annotations: map[string]string{v1beta1.KubeAPIApprovedAnnotation: "valid"}, ResourceVersion: "1"},
				Spec: apiextensions.CustomResourceDefinitionSpec{
					Validation: &apiextensions.CustomResourceValidation{
						OpenAPIV3Schema: &apiextensions.JSONSchemaProps{
							Type: "object",

		{newPPC64ShiftAuxInt(17, 48, 63, 64), 32, false, 0, 0},
	}
	for i, v := range tests {
		result := mergePPC64ClrlsldiSrw(int64(v.clrlsldi), v.srw)
		if v.valid && result == 0 {
			t.Errorf("mergePPC64ClrlsldiSrw(Test %d) did not merge", i)
		} else if !v.valid && result != 0 {
			t.Errorf("mergePPC64ClrlsldiSrw(Test %d) should return 0", i)
		} else if r, _, _, m := DecodePPC64RotateMask(result); v.rotate != r || v.mask != m {

      tls:
        mode: SIMPLE
        # use a valid credential here
        credentialName: "$CREDENTIAL_NAME"
      hosts:
      # use a valid gateway host and domain for istiod
      - "ISTIOD-HOST.DOMAIN"
    - port:
        name: https-istiodwebhook
        number: 15017
        protocol: https
      tls:
        mode: SIMPLE
        # use a valid credential here
        credentialName: "$CREDENTIAL_NAME"

		name  string
		tags  labels.Instance
		valid bool
	}{
		{
			name:  "empty tags",
			valid: true,
		},
		{
			name: "bad tag",
			tags: labels.Instance{"^": "^"},
		},
		{
			name:  "good tag",
			tags:  labels.Instance{"key": "value"},
			valid: true,
		},
		{
			name:  "good tag - empty value",
			tags:  labels.Instance{"key": ""},
			valid: true,
		},
		{

app = FastAPI()


class Item(BaseModel):
    name: str
    price: Optional[float] = None
    owner_ids: Optional[List[int]] = None


@app.get("/items/valid", response_model=Item)
def get_valid():
    return {"name": "valid", "price": 1.0}


@app.get("/items/coerce", response_model=Item)
def get_coerce():
    return {"name": "coerce", "price": "1.0"}