ctx := &tls.UpstreamTlsContext{}
					if err := upstreamProxyProtocol.TransportSocket.GetTypedConfig().UnmarshalTo(ctx); err != nil {
						t.Fatal(err)
					}
				}
			}

			for i, match := range cluster.TransportSocketMatches {
				if err := match.TransportSocket.GetTypedConfig().UnmarshalTo(upstreamProxyProtocol); err != nil {
					t.Fatal(err)
				}

     * If {@code element} is not {@code null}, child configuration element with the specified name will
     * be unmarshalled.
     *
     * @param configuration The configuration to unmarshal, may be {@code null}.
     * @param element Configuration element name to unmarshal or {@code null} to unmarshal entire configuration.
     * @return This request for chaining, never {@code null}.
     */

	"k8s.io/apimachinery/pkg/runtime/schema"
)

// nonCacheableTestObject implements json.Marshaler and proto.Marshaler interfaces
// for mocking purpose.
// +k8s:deepcopy-gen=false
type noncacheableTestObject struct {
	gvk schema.GroupVersionKind
}

// MarshalJSON implements json.Marshaler interface.
func (*noncacheableTestObject) MarshalJSON() ([]byte, error) {
	return []byte("\"json-result\""), nil
}

}

// UnmarshalJSON implements the json.Unmarshaller interface.
func (intstr *IntOrString) UnmarshalJSON(value []byte) error {
	if value[0] == '"' {
		intstr.Type = String
		return json.Unmarshal(value, &intstr.StrVal)
	}
	intstr.Type = Int
	return json.Unmarshal(value, &intstr.IntVal)
}

func (intstr *IntOrString) UnmarshalCBOR(value []byte) error {
	if err := cbor.Unmarshal(value, &intstr.StrVal); err == nil {

func (cp *Data) MarshalCheckpoint() ([]byte, error) {
	cp.Checksum = checksum.New(cp.Data)
	return json.Marshal(*cp)
}

// UnmarshalCheckpoint returns unmarshalled data
func (cp *Data) UnmarshalCheckpoint(blob []byte) error {
	return json.Unmarshal(blob, cp)
}

// VerifyChecksum verifies that passed checksum is same as calculated checksum
func (cp *Data) VerifyChecksum() error {
	return cp.Checksum.Verify(cp.Data)

			t.Fatalf("Test %d: failed to marshal DEK: %v", i, err)
		}

		var key DEK
		if err = key.UnmarshalText(text); err != nil {
			t.Fatalf("Test %d: failed to unmarshal DEK: %v", i, err)
		}
		if key.Plaintext != nil {
			t.Fatalf("Test %d: unmarshaled DEK contains non-nil plaintext", i)
		}
		if !bytes.Equal(key.Ciphertext, test.Key.Ciphertext) {

“html” for Printer.HTML, “markdown” for Printer.Markdown, and “text” for Printer.Text.
The format can also be “dump” for a textual dump of the raw data structures.

The text before the `-- input --` line, if present, is JSON to be unmarshaled
to initialize a comment.Printer. For example, this test case sets the Printer's
TextWidth field to 20:

	{"TextWidth": 20}
	-- input --
	Package gob manages streams of gobs - binary values exchanged between an

	bootstrapDumpAny, err := w.getSection(bootstrap)
	if err != nil {
		return nil, err
	}
	bootstrapDump := &admin.BootstrapConfigDump{}
	err = bootstrapDumpAny.UnmarshalTo(bootstrapDump)
	if err != nil {
		return nil, err
	}
	return bootstrapDump, nil

	endpointsDumpAny, err := w.getSection(endpoints)
	if err != nil {
		return nil, nil
	}
	endpointsDump := &admin.EndpointsConfigDump{}
	err = endpointsDumpAny.UnmarshalTo(endpointsDump)
	if err != nil {
		return nil, err
	}
	return endpointsDump, nil

	raw, _ := f.ConfigGen.BuildClusters(p, &model.PushRequest{Push: f.PushContext()})
	res := make([]*cluster.Cluster, 0, len(raw))
	for _, r := range raw {
		c := &cluster.Cluster{}
		if err := r.Resource.UnmarshalTo(c); err != nil {
			f.t.Fatal(err)
		}
		res = append(res, c)
	}
	return res
}

func (f *ConfigGenTest) DeltaClusters(
	p *model.Proxy,
	configUpdated sets.Set[model.ConfigKey],