},
		},
	}

	Strategy.PrepareForCreate(ctx, podTemplate)
	if podTemplate.Generation != 1 {
		t.Errorf("expected Generation=1, got %d", podTemplate.Generation)
	}
	errs := Strategy.Validate(ctx, podTemplate)
	if len(errs) != 0 {
		t.Errorf("Unexpected error validating %v", errs)
	}

	// ensure we do not change generation for non-spec updates
	updatedLabel := podTemplate.DeepCopy()

		NewFunc:                   func() runtime.Object { return &api.PodTemplate{} },
		NewListFunc:               func() runtime.Object { return &api.PodTemplateList{} },
		DefaultQualifiedResource:  api.Resource("podtemplates"),
		SingularQualifiedResource: api.Resource("podtemplate"),

		CreateStrategy: podtemplate.Strategy,
		UpdateStrategy: podtemplate.Strategy,
		DeleteStrategy: podtemplate.Strategy,

		ReturnDeletedObject: true,

	template := obj.(*api.PodTemplate)
	template.Generation = 1
	pod.DropDisabledTemplateFields(&template.Template, nil)
}

// Validate validates a new pod template.
func (podTemplateStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList {
	template := obj.(*api.PodTemplate)
	opts := pod.GetValidationOptionsFromPodTemplate(&template.Template, nil)

See the License for the specific language governing permissions and
limitations under the License.
*/

// Package podtemplate provides RESTStorage implementations for storing PodTemplate API objects.

	}
	rest, err := NewREST(restOptions)
	if err != nil {
		t.Fatalf("unexpected error from REST storage: %v", err)
	}
	return rest, server
}

func validNewPodTemplate(name string) *api.PodTemplate {
	return &api.PodTemplate{
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: metav1.NamespaceDefault,
		},
		Template: api.PodTemplateSpec{
			ObjectMeta: metav1.ObjectMeta{

			Revision: revision,
		}
	}

	podTemplate := api.PodTemplate{
		Template: api.PodTemplateSpec{
			Spec: api.PodSpec{
				RestartPolicy: api.RestartPolicyAlways,
				DNSPolicy:     api.DNSClusterFirst,
			},
			ObjectMeta: metav1.ObjectMeta{
				Labels: map[string]string{"a": "b"},
			},
		},
	}

	ss := mkStatefulSet(&podTemplate)

	var (

	}
	if Strategy.AllowCreateOnUpdate() {
		t.Errorf("ReplicationController should not allow create on update")
	}

	validSelector := map[string]string{"a": "b"}
	validPodTemplate := api.PodTemplate{
		Template: api.PodTemplateSpec{
			ObjectMeta: metav1.ObjectMeta{
				Labels: validSelector,
			},
			Spec: api.PodSpec{
				RestartPolicy: api.RestartPolicyAlways,
				DNSPolicy:     api.DNSClusterFirst,

	}
	if Strategy.AllowCreateOnUpdate() {
		t.Errorf("ReplicaSet should not allow create on update")
	}

	validSelector := map[string]string{"a": "b"}
	validPodTemplate := api.PodTemplate{
		Template: api.PodTemplateSpec{
			ObjectMeta: metav1.ObjectMeta{
				Labels: validSelector,
			},
			Spec: api.PodSpec{
				RestartPolicy: api.RestartPolicyAlways,
				DNSPolicy:     api.DNSClusterFirst,

      "singularName": "",
      "verbs": [
        "get",
        "patch",
        "update"
      ]
    },
    {
      "kind": "PodTemplate",
      "name": "podtemplates",
      "namespaced": true,
      "singularName": "podtemplate",
      "storageVersionHash": "LIXB2x4IFpk=",
      "verbs": [
        "create",
        "delete",
        "deletecollection",
        "get",

	if err := scheme.AddIgnoredConversionType(&metav1.TypeMeta{}, &metav1.TypeMeta{}); err != nil {
		return err
	}
	scheme.AddKnownTypes(SchemeGroupVersion,
		&Pod{},
		&PodList{},
		&PodStatusResult{},
		&PodTemplate{},
		&PodTemplateList{},
		&ReplicationControllerList{},
		&ReplicationController{},
		&ServiceList{},
		&Service{},
		&ServiceProxyOptions{},
		&NodeList{},
		&Node{},
		&NodeProxyOptions{},