"absent": nil,
			},
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			v := &ObjectVal{
				typeRef: nil, // safe in this test, otherwise put a mock
				fields:  tc.fields,
			}
			converted := v.Value()
			if !reflect.DeepEqual(tc.expected, converted) {
				t.Errorf("wrong result, expected %v but got %v", tc.expected, converted)
			}
		})
	}

		},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			_, ctx := ktesting.NewTestContext(t)
			ctx, cancel := context.WithCancel(ctx)
			defer cancel()
			m, err := NewMap(ctx, tc.cfgs, fakeRegistry, nilRecorderFactory)
			if err := checkErr(err, tc.wantErr); err != nil {
				t.Fatal(err)
			}
			if len(tc.wantErr) != 0 {
				return
			}

					"sa1":    {},
					"sa-vm1": {},
					"sa-vm2": {},
				},
			}
			originalEndpointsShard.Shards[tc.shardKey] = tc.endpoints
			ret := updateShardServiceAccount(originalEndpointsShard, "test-svc")
			if ret != tc.expect {
				t.Errorf("expect UpdateServiceAccount %v, but got %v", tc.expect, ret)
			}
		})
	}

		t.Fatal(err)
	}

	for _, tc := range testcases {
		t.Run(tc.Name, func(t *testing.T) {
			err := scheme.Convert(tc.In, tc.Out, nil)
			if err != nil {
				if len(tc.ExpectErr) == 0 {
					t.Fatalf("unexpected error %v", err)
				}
				if !strings.Contains(err.Error(), tc.ExpectErr) {
					t.Fatalf("expected error %s, got %v", tc.ExpectErr, err)
				}
				return
			}

			cfg:            &ClusterConfiguration{},
			expectedResult: "",
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			if result := tc.cfg.EncryptionAlgorithmType(); result != tc.expectedResult {
				t.Errorf("expected result: %s, got: %s", tc.expectedResult, result)
			}
		})
	}

		},
		// main container = 0 delay, nothing to wait on
		{
			containerName: "main",
			expectedDelay: 0,
		},
	} {
		if got := getDelay(tc.containerName); got != tc.expectedDelay {
			t.Errorf("expected delay for container %s = %d, got %d", tc.containerName, tc.expectedDelay, got)
		}
	}
}

func TestTerminationOrderingObeysGrace(t *testing.T) {
	restartPolicy := v1.ContainerRestartPolicyAlways

			want: &uri_template.UriTemplateMatchConfig{
				PathTemplate: "/*/*/foo/**/bar",
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			got := PathTemplateMatcher(tc.path)
			if !cmp.Equal(got, tc.want, protocmp.Transform()) {
				t.Errorf("want %v but got %v", tc.want, got)
			}
		})
	}

				{name: "kube-scheduler", url: "https://127.0.0.1:10259/healthz"},
			},
		},
	}

	for _, tc := range testcases {
		t.Run(tc.name, func(t *testing.T) {
			actual := getControlPlaneComponents(tc.cfg)
			if !reflect.DeepEqual(tc.expected, actual) {
				t.Fatalf("expected result: %+v, got: %+v", tc.expected, actual)
			}
		})
	}

			expectedValue: map[string]any{"spec": map[string]any{"replicas": int64(3)}},
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			_, option := NewTypeProviderAndEnvOption(&mockTypeResolver{})
			env := mustCreateEnv(t, option)
			ast, issues := env.Compile(tc.expression)
			if issues != nil {
				t.Fatalf("unexpected issues during compilation: %v", issues)
			}
			program, err := env.Program(ast)

	}
	compiler := NewCompiler(extended)

	for _, tc := range cases {
		envType := tc.envType
		if envType == "" {
			envType = environment.NewExpressions
		}
		t.Run(tc.name, func(t *testing.T) {
			for _, expr := range tc.expressions {
				t.Run(expr, func(t *testing.T) {
					t.Run("expression", func(t *testing.T) {
						options := OptionalVariableDeclarations{HasParams: tc.hasParams, HasAuthorizer: tc.hasAuthorizer}