}
    }, ;

    abstract fun setBody(
      response: MockResponse.Builder,
      content: Buffer?,
      chunkSize: Int,
    )

    abstract fun newRequestBody(body: String): RequestBody

    fun setBody(
      response: MockResponse.Builder,
      content: String?,
      chunkSize: Int,
    ) {
      setBody(response, Buffer().writeUtf8(content!!), chunkSize)
    }

  }

  internal enum class TransferKind {
    CHUNKED {
      override fun setBody(
        response: MockResponse.Builder,
        content: Buffer,
        chunkSize: Int,
      ) {
        response.chunkedBody(content, chunkSize)
      }
    },
    FIXED_LENGTH {
      override fun setBody(
        response: MockResponse.Builder,
        content: Buffer,
        chunkSize: Int,

			defer cancel()
			f, err := newFrameworkWithQueueSortAndBind(ctx, registry, profile, WithPodNominator(podNominator))
			if err != nil {
				t.Fatalf("fail to create framework: %s", err)
			}
			tt.nodeInfo.SetNode(tt.node)
			gotStatus := f.RunFilterPluginsWithNominatedPods(ctx, framework.NewCycleState(), tt.pod, tt.nodeInfo)
			if diff := cmp.Diff(gotStatus, tt.wantStatus, cmpOpts...); diff != "" {

			secretManager = secret.NewCachingSecretManager(
				klet.kubeClient, manager.GetObjectTTLFromNodeFunc(klet.GetNode))
			configMapManager = configmap.NewCachingConfigMapManager(
				klet.kubeClient, manager.GetObjectTTLFromNodeFunc(klet.GetNode))
		case kubeletconfiginternal.GetChangeDetectionStrategy:
			secretManager = secret.NewSimpleSecretManager(klet.kubeClient)

			defer testKubelet.Cleanup()
			kubelet := testKubelet.kubelet
			// Ensure we capture actions on the heartbeat client only.
			// We don't set it to nil or GetNode() doesn't read from nodeLister.
			kubelet.kubeClient = &fake.Clientset{}
			kubeClient := testKubelet.fakeKubeClient

			node := &v1.Node{
				ObjectMeta: metav1.ObjectMeta{

				// when the pod specifies an fsGroup, and if the directory is not created here, Docker will
				// later auto-create it with the incorrect mode 0750
				// Make extra care not to escape the volume!
				perm, err := hu.GetMode(volumePath)
				if err != nil {
					return nil, cleanupAction, err
				}
				if err := subpather.SafeMakeDir(subPath, volumePath, perm); err != nil {

				}
			}
		})
	}
}

func TestPreFilterDisabled(t *testing.T) {
	pod := &v1.Pod{}
	nodeInfo := framework.NewNodeInfo()
	node := v1.Node{}
	nodeInfo.SetNode(&node)
	_, ctx := ktesting.NewTestContext(t)
	p := plugintesting.SetupPlugin(ctx, t, topologySpreadFunc, &config.PodTopologySpreadArgs{DefaultingType: config.ListDefaulting}, cache.NewEmptySnapshot())

		return errs.Unwrap()
	})

func validateSidecarOutboundTrafficPolicy(tp *networking.OutboundTrafficPolicy) (errs error) {
	if tp == nil {
		return
	}
	mode := tp.GetMode()
	if tp.EgressProxy != nil {
		if mode != networking.OutboundTrafficPolicy_ALLOW_ANY {
			errs = appendErrors(errs, fmt.Errorf("sidecar: egress_proxy must be set only with ALLOW_ANY outbound_traffic_policy mode"))
			return

					return tt.terminatingErr
				}
			}
			if tt.prepareWorker != nil {
				tt.prepareWorker(t, podWorkers, processed)
			}

			testKubelet.fakeRuntime.PodList = tt.runtimePods
			kl.podManager.SetPods(tt.pods)

			for _, reject := range tt.rejectedPods {
				pod, ok := kl.podManager.GetPodByUID(reject.uid)
				if !ok {
					t.Fatalf("unable to reject pod by UID %v", reject.uid)
				}