}
			if patchType != tc.expectedPatchType {
				t.Errorf("expected patch type: %v, got: %v", tc.expectedPatchType, patchType)
			}
		})
	}
}

func TestCreatePatchSet(t *testing.T) {
	tests := []struct {
		name             string
		targetName       string
		patchType        types.PatchType
		expectedPatchSet *patchSet
		data             string
	}{

				DryRun:             arRequest.DryRun,
				Options:            arRequest.Options,
			}
		}
		if arResponse != nil {
			var patchType *kubeApiAdmissionv1beta1.PatchType
			if arResponse.PatchType != nil {
				patchType = (*kubeApiAdmissionv1beta1.PatchType)(arResponse.PatchType)
			}
			arv1beta1.Response = &kubeApiAdmissionv1beta1.AdmissionResponse{
				UID:              arResponse.UID,

	v1beta1JSONPatch := admissionv1beta1.PatchTypeJSONPatch
	v1JSONPatch := admissionv1.PatchTypeJSONPatch

	emptyv1beta1Patch := admissionv1beta1.PatchType("")
	emptyv1Patch := admissionv1.PatchType("")

	invalidv1beta1Patch := admissionv1beta1.PatchType("Foo")
	invalidv1Patch := admissionv1.PatchType("Foo")

	testcases := []struct {
		name     string
		uid      types.UID
		mutating bool
		review   runtime.Object

	}
	patchType := patchTypes[sub[4]]

	return targetName, patchType, nil, nil
}

// createPatchSet creates a patchSet object, by splitting the given "data" by "\n---".
func createPatchSet(targetName string, patchType types.PatchType, data string) (*patchSet, error) {
	var patches []string

	// Split the patches and convert them to JSON.

	}
}

func (w *webhookAnnotator) addPatchAnnotation(patch interface{}, patchType admissionv1.PatchType) {
	if w.attr == nil || w.attr.Attributes == nil {
		return
	}
	var value string
	var err error
	switch patchType {
	case admissionv1.PatchTypeJSONPatch:
		value, err = jsonPatchAnnotationValue(w.configuration, w.webhook, patch)
		if err != nil {

		opts      metav1.PatchOptions
		patchType types.PatchType
	}{{
		opts: metav1.PatchOptions{
			Force:        boolPtr(true),
			FieldManager: "kubectl",
		},
		patchType: types.ApplyPatchType,
	}, {
		opts: metav1.PatchOptions{
			FieldManager: "kubectl",
		},
		patchType: types.ApplyPatchType,
	}, {
		opts:      metav1.PatchOptions{},
		patchType: types.MergePatchType,
	}, {

		contentType := req.Header.Get("Content-Type")
		// Remove "; charset=" if included in header.
		if idx := strings.Index(contentType, ";"); idx > 0 {
			contentType = contentType[:idx]
		}
		patchType := types.PatchType(contentType)

		// Ensure the patchType is one we support
		if !sets.NewString(patchTypes...).Has(contentType) {
			scope.err(negotiation.NewUnsupportedMediaTypeError(patchTypes), w, req)
			return
		}

}

func genPatchBytes(oldRes, modRes runtime.Object, patchType types.PatchType) ([]byte, error) {
	oldJSON, err := json.Marshal(oldRes)
	if err != nil {
		return nil, fmt.Errorf("failed marhsalling original resource: %v", err)
	}
	newJSON, err := json.Marshal(modRes)
	if err != nil {
		return nil, fmt.Errorf("failed marhsalling modified resource: %v", err)
	}
	switch patchType {
	case types.JSONPatchType:

			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if m.PatchType != nil {
		i -= len(*m.PatchType)
		copy(dAtA[i:], *m.PatchType)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PatchType)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Patch != nil {
		i -= len(m.Patch)
		copy(dAtA[i:], m.Patch)

			i--
			dAtA[i] = 0xa
			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if m.PatchType != nil {
		i -= len(*m.PatchType)
		copy(dAtA[i:], *m.PatchType)
		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PatchType)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Patch != nil {
		i -= len(m.Patch)
		copy(dAtA[i:], m.Patch)