}
		}
	}
}

func TestIntJSONEncodingNil(t *testing.T) {
	var x *Int
	b, err := x.MarshalJSON()
	if err != nil {
		t.Fatalf("marshaling of nil failed: %s", err)
	}
	got := string(b)
	want := "null"
	if got != want {
		t.Fatalf("marshaling of nil failed: got %s want %s", got, want)
	}
}

func TestIntXMLEncoding(t *testing.T) {
	for _, test := range encodingTests {

*/

package core

import "encoding/json"

// This file implements json marshaling/unmarshaling interfaces on objects that are currently marshaled into annotations
// to prevent anyone from marshaling these internal structs.

var _ = json.Marshaler(&AvoidPods{})
var _ = json.Unmarshaler(&AvoidPods{})

// MarshalJSON panics to prevent marshalling of internal structs

	if m == nil {
		return &Timestamp{}
	}

	// truncate precision to microseconds to match JSON marshaling/unmarshaling
	truncatedNanoseconds := time.Duration(m.Time.Nanosecond()).Truncate(time.Microsecond)
	return &Timestamp{
		Seconds: m.Time.Unix(),
		Nanos:   int32(truncatedNanoseconds),
	}
}

// Size implements the protobuf marshalling interface.
func (m *MicroTime) Size() (n int) {
	if m == nil || m.Time.IsZero() {
		return 0

	m.Time = time.Unix(p.Seconds, int64(0)).Local()
	return nil
}

// Marshal implements the protobuf marshaling interface.
func (m *Time) Marshal() (data []byte, err error) {
	if m == nil || m.Time.IsZero() {
		return nil, nil
	}
	return m.ProtoTime().Marshal()
}

// MarshalTo implements the protobuf marshaling interface.
func (m *Time) MarshalTo(data []byte) (int, error) {
	if m == nil || m.Time.IsZero() {
		return 0, nil

			var tx Rat
			tx.SetString(num + "/" + denom)
			b, err := json.Marshal(&tx)
			if err != nil {
				t.Errorf("marshaling of %s failed: %s", &tx, err)
				continue
			}
			var rx Rat
			if err := json.Unmarshal(b, &rx); err != nil {
				t.Errorf("unmarshaling of %s failed: %s", &tx, err)
				continue
			}
			if rx.Cmp(&tx) != 0 {
				t.Errorf("JSON encoding of %s failed: got %s want %s", &tx, &rx, &tx)

// as they can be used for serialization in communicating with programs
// written with different library versions.
// The policy for packages maintained by the Go project is to only allow
// the addition of marshaling functions if no existing, reasonable marshaling exists.
package encoding

// BinaryMarshaler is the interface implemented by an object that can
// marshal itself into a binary form.
//

	out, err := MessageToAnyWithError(msg)
	if err != nil {
		log.Error(fmt.Sprintf("error marshaling Any %s: %v", prototext.Format(msg), err))
		return nil
	}
	return out
}

func TypedStructWithFields(typeURL string, fields map[string]interface{}) *anypb.Any {
	value, err := structpb.NewStruct(fields)
	if err != nil {
		log.Error(fmt.Sprintf("error marshaling struct %s: %v", typeURL, err))
	}
	return MessageToAny(&udpa.TypedStruct{

	tag          *int   // the EXPLICIT or IMPLICIT tag (maybe nil).
	stringType   int    // the string tag to use when marshaling.
	timeType     int    // the time tag to use when marshaling.
	set          bool   // true iff this should be encoded as a SET
	omitEmpty    bool   // true iff this should be omitted if empty when marshaling.

	// Invariants:
	//   if explicit is set, tag is non-nil.
}

The new [Encode] and [Decode] functions are byte slice equivalents
to [Read] and [Write].

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package codegen

//go:noinline
func f(x int32) {
}

func g(p *int32) {
	// argument marshaling code should live at line 17, not line 15.
	x := *p
	// 386: `MOVL\s[A-Z]+,\s\(SP\)`
	f(x)