update := UpdateOptions{}
			f.Fuzz(&update)

			b, err := json.Marshal(update)
			if err != nil {
				t.Fatalf("failed to marshal UpdateOptions (%v): %v", err, update)
			}
			patch := PatchOptions{}
			err = json.Unmarshal(b, &patch)
			if err != nil {
				t.Fatalf("failed to unmarshal UpdateOptions into PatchOptions: %v", err)
			}

			b, err = json.Marshal(patch)
			if err != nil {

func ParsePKCS8PrivateKey(der []byte) (key any, err error) {
	var privKey pkcs8
	if _, err := asn1.Unmarshal(der, &privKey); err != nil {
		if _, err := asn1.Unmarshal(der, &ecPrivateKey{}); err == nil {
			return nil, errors.New("x509: failed to parse private key (use ParseECPrivateKey instead for this key format)")
		}
		if _, err := asn1.Unmarshal(der, &pkcs1PrivateKey{}); err == nil {

		t.Errorf("IsOnCurve(∞) == true")
	}

	if xx, yy := Unmarshal(curve, Marshal(curve, x0, y0)); xx != nil || yy != nil {
		t.Errorf("Unmarshal(Marshal(∞)) did not return an error")
	}
	// We don't test UnmarshalCompressed(MarshalCompressed(∞)) because there are
	// two valid points with x = 0.
	if xx, yy := Unmarshal(curve, []byte{0x00}); xx != nil || yy != nil {
		t.Errorf("Unmarshal(∞) did not return an error")
	}

	}

	for _, c := range cases {
		var result JSONSchemaPropsOrBoolHolder
		if err := json.Unmarshal([]byte(c.input), &result); err != nil {
			t.Errorf("Failed to unmarshal input '%v': %v", c.input, err)
		}
		if !reflect.DeepEqual(result, c.result) {
			t.Errorf("Failed to unmarshal input '%v': expected %+v, got %+v", c.input, c.result, result)
		}
	}
}

		reader.Reset(js)
		return m.Unmarshal(reader, pb)
	}
	return nil
}

// ApplyJSONStrict unmarshals a JSON string into a proto message.
func ApplyJSONStrict(js string, pb proto.Message) error {
	reader := strings.NewReader(js)
	m := jsonpb.Unmarshaler{}
	return m.Unmarshal(reader, pb)

	iop := &operator_v1alpha1.IstioOperator{}
	if allowUnknownField {
		if err := yaml.Unmarshal([]byte(iopYAML), iop); err != nil {
			return nil, fmt.Errorf("could not unmarshal: %v", err)
		}
	} else {
		if err := yaml.UnmarshalStrict([]byte(iopYAML), iop); err != nil {
			return nil, fmt.Errorf("could not unmarshal: %v", err)
		}
	}
	return iop, nil

				cborFromOriginal, err := modePair.enc.Marshal(original)
				if err != nil {
					t.Fatalf("unexpected error from Marshal of original: %v", err)
				}

				var iface interface{}
				if err := modePair.dec.Unmarshal(cborFromOriginal, &iface); err != nil {
					t.Fatalf("unexpected error from Unmarshal into %T: %v", &iface, err)
				}

				cborFromIface, err := modePair.enc.Marshal(iface)
				if err != nil {

	{
		var v *[]interface{}
		err := Unmarshal([]byte(`[]`), v)
		goerr := gojson.Unmarshal([]byte(`[]`), v)
		if err == nil || goerr == nil || err.Error() != goerr.Error() {
			t.Fatalf("expected error matching stdlib, got %v, %v", err, goerr)
		} else {
			t.Log(err)
		}
	}

	{
		var v *map[string]interface{}
		err := Unmarshal([]byte(`{}`), v)
		goerr := gojson.Unmarshal([]byte(`{}`), v)

	// a, b, c, aa, bb, cc

	output, err := Marshal(testStruct)
	if err != nil {
		t.Errorf("%v", err)
	}

	expectedOrder := []string{"a", "b", "c", "aa", "bb", "cc"}
	var resultStruct struct {
		Strings []string `asn1:"set"`
	}
	rest, err := Unmarshal(output, &resultStruct)
	if err != nil {
		t.Errorf("%v", err)
	}
	if len(rest) != 0 {
		t.Error("Unmarshal returned extra garbage")
	}

	}

	for _, c := range cases {
		var result JSONSchemaPropsOrBoolHolder
		if err := json.Unmarshal([]byte(c.input), &result); err != nil {
			t.Errorf("Failed to unmarshal input '%v': %v", c.input, err)
		}
		if !reflect.DeepEqual(result, c.result) {
			t.Errorf("Failed to unmarshal input '%v': expected %+v, got %+v", c.input, c.result, result)
		}
	}
}