if t.IsZero() {
		// Encode unset/nil objects as JSON's "null".
		return []byte("null"), nil
	}

	return json.Marshal(t.UTC().Format(RFC3339Micro))
}

func (t MicroTime) MarshalCBOR() ([]byte, error) {
	if t.IsZero() {
		return cbor.Marshal(nil)
	}
	return cbor.Marshal(t.UTC().Format(RFC3339Micro))
}

// OpenAPISchemaType is used by the kube-openapi generator when constructing

	buf = append(buf, '"')
	// time cannot contain non escapable JSON characters
	buf = t.UTC().AppendFormat(buf, time.RFC3339)
	buf = append(buf, '"')
	return buf, nil
}

func (t Time) MarshalCBOR() ([]byte, error) {
	if t.IsZero() {
		return cbor.Marshal(nil)
	}

	return cbor.Marshal(t.UTC().Format(time.RFC3339))
}

// ToUnstructured implements the value.UnstructuredConverter interface.

		return json.Marshal(intstr.IntVal)
	case String:
		return json.Marshal(intstr.StrVal)
	default:
		return []byte{}, fmt.Errorf("impossible IntOrString.Type")
	}
}

func (intstr IntOrString) MarshalCBOR() ([]byte, error) {
	switch intstr.Type {
	case Int:
		return cbor.Marshal(intstr.IntVal)
	case String:
		return cbor.Marshal(intstr.StrVal)
	default:
		return nil, fmt.Errorf("impossible IntOrString.Type")

	} {
		t.Run(fmt.Sprintf("%+v", tc.in), func(t *testing.T) {
			got, err := tc.in.MarshalCBOR()
			if err != nil {
				t.Fatal(err)
			}
			if diff := cmp.Diff(tc.out, got); diff != "" {
				t.Errorf("unexpected output:\n%s", diff)
			}
		})
	}
}

	} {
		t.Run(fmt.Sprintf("%+v", tc.in), func(t *testing.T) {
			got, err := tc.in.MarshalCBOR()
			if err != nil {
				t.Fatal(err)
			}
			if diff := cmp.Diff(tc.out, got); diff != "" {
				t.Errorf("unexpected output:\n%s", diff)
			}
		})
	}
}

			want: []byte{0x3a, 0x7f, 0xff, 0xff, 0xff},
		},
	} {
		t.Run(fmt.Sprintf("{Type:%d,IntVal:%d,StrVal:%q}", tc.in.Type, tc.in.IntVal, tc.in.StrVal), func(t *testing.T) {
			got, err := tc.in.MarshalCBOR()
			if tc.assertOnError != nil {
				tc.assertOnError(t, err)
			} else if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}
			if diff := cmp.Diff(got, tc.want); diff != "" {

}

func (p anyObject) GetObjectKind() schema.ObjectKind {
	return schema.EmptyObjectKind
}

func (anyObject) DeepCopyObject() runtime.Object {
	panic("unimplemented")
}

func (p anyObject) MarshalCBOR() ([]byte, error) {
	return modes.Encode.Marshal(p.Value)
}

func (p *anyObject) UnmarshalCBOR(in []byte) error {
	return modes.Decode.Unmarshal(in, &p.Value)
}

func TestEncode(t *testing.T) {

	// append
	result = result[:1]
	result = append(result, number...)
	result = append(result, suffix...)
	result = append(result, '"')
	return result, nil
}

func (q Quantity) MarshalCBOR() ([]byte, error) {
	// The call to String() should never return the string "<nil>" because the receiver's
	// address will never be nil.
	return cbor.Marshal(q.String())
}