if err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(NullBytes, marshaled) {
		t.Errorf("Expected Marshal of NullRawValue to yield %x, got %x", NullBytes, marshaled)
	}

	unmarshaled := RawValue{}
	if _, err := Unmarshal(NullBytes, &unmarshaled); err != nil {
		t.Fatal(err)
	}

	unmarshaled.FullBytes = NullRawValue.FullBytes
	if len(unmarshaled.Bytes) == 0 {

	return nil
}

// ProxyConfig can only be marshaled using (gogo) jsonpb. However, the rest of node meta is not a proto
// To allow marshaling, we need to define a custom type that calls out to the gogo marshaller
type NodeMetaProxyConfig meshconfig.ProxyConfig

func (s *NodeMetaProxyConfig) MarshalJSON() ([]byte, error) {
	pc := (*meshconfig.ProxyConfig)(s)
	return protomarshal.Marshal(pc)
}

		}
	}
}

func TestUnmarshalText(t *testing.T) {
	unmarshaled := new(Regexp)
	for i := range goodRe {
		re := compileTest(t, goodRe[i], "")
		marshaled, err := re.MarshalText()
		if err != nil {
			t.Errorf("regexp %#q failed to marshal: %s", re, err)
			continue
		}
		if err := unmarshaled.UnmarshalText(marshaled); err != nil {
			t.Errorf("regexp %#q failed to unmarshal: %s", re, err)
			continue

	p.encodeMu.Lock()
	p.preEncode()
	b := marshal(p)
	p.encodeMu.Unlock()
	return b
}

// Write writes the profile as a gzip-compressed marshaled protobuf.
func (p *Profile) Write(w io.Writer) error {
	zw := gzip.NewWriter(w)
	defer zw.Close()
	_, err := zw.Write(serialize(p))
	return err
}

// WriteUncompressed writes the profile as a marshaled protobuf.

package md5

import (
	"bytes"
	"crypto/rand"
	"encoding"
	"fmt"
	"hash"
	"io"
	"testing"
	"unsafe"
)

type md5Test struct {
	out       string
	in        string
	halfState string // marshaled hash state after first half of in written, used by TestGoldenMarshal
}

var golden = []md5Test{

	}

	if err := p.postDecode(); err != nil {
		return nil, err
	}

	return p, nil
}

// Write writes the profile as a gzip-compressed marshaled protobuf.
func (p *Profile) Write(w io.Writer) error {
	p.preEncode()
	b := marshal(p)
	zw := gzip.NewWriter(w)
	defer zw.Close()
	_, err := zw.Write(b)
	return err
}

// CheckValid tests whether the profile is valid. Checks include, but are

import (
	"bytes"
	"crypto/internal/boring"
	"crypto/rand"
	"encoding"
	"fmt"
	"hash"
	"io"
	"testing"
)

type sha1Test struct {
	out       string
	in        string
	halfState string // marshaled hash state after first half of in written, used by TestGoldenMarshal
}

var golden = []sha1Test{

	"unicode/utf8"
	_ "unsafe" // for linkname
)

// Marshal returns the JSON encoding of v.
//
// Marshal traverses the value v recursively.
// If an encountered value implements [Marshaler]
// and is not a nil pointer, Marshal calls [Marshaler.MarshalJSON]
// to produce JSON. If no [Marshaler.MarshalJSON] method is present but the
// value implements [encoding.TextMarshaler] instead, Marshal calls

	}
}

// roundTrip applies a single round-trip test to the given runtime object
// using the given codec.  The round-trip test ensures that an object can be
// deep-copied, converted, marshaled and back without loss of data.
//
// For internal types this means
//
//	internal -> external -> json/protobuf -> external -> internal.
//
// For external types this means
//

func TestReadStaticPodFromDisk(t *testing.T) {
	tests := []struct {
		description   string
		podYaml       string
		expectErr     bool
		writeManifest bool
	}{
		{
			description:   "valid pod is marshaled",
			podYaml:       validPod,
			writeManifest: true,
			expectErr:     false,
		},
		{
			description:   "invalid pod fails to unmarshal",
			podYaml:       invalidPod,
			writeManifest: true,