Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 decode.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package jsonpb import ( "encoding/json" "errors" "fmt" "io" "math" "reflect" "strconv" "strings" "time" "github.com/golang/protobuf/proto" "google.golang.org/protobuf/encoding/protojson" protoV2 "google.golang.org/protobuf/proto" "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoregistry" ) const wrapJSONUnmarshalV2 = false // UnmarshalNext unmarshals the next JSON object from d into m. func UnmarshalNext(d json.Decoder, m proto.Message) error { return new(Unmarshaler).UnmarshalNext(d, m) } // Unmarshal unmarshals a JSON object from r into m. func Unmarshal(r io.Reader, m proto.Message) error { return new(Unmarshaler).Unmarshal(r, m) } // UnmarshalString unmarshals a JSON object from s into m. func UnmarshalString(s string, m proto.Message) error { return new(Unmarshaler).Unmarshal(strings.NewReader(s), m) } // Unmarshaler is a configurable object for converting from a JSON // representation to a protocol buffer object. type Unmarshaler struct { // AllowUnknownFields specifies whether to allow messages to contain // unknown JSON fields, as opposed to failing to unmarshal. AllowUnknownFields bool // AnyResolver is used to resolve the google.protobuf.Any well-known type. // If unset, the global registry is used by default. AnyResolver AnyResolver } // JSONPBUnmarshaler is implemented by protobuf messages that customize the way // they are unmarshaled from JSON. Messages that implement this should also // implement JSONPBMarshaler so that the custom format can be produced. // // The JSON unmarshaling must follow the JSON to proto specification: // https://developers.google.com/protocol-buffers/docs/proto3#json // // Deprecated: Custom types should implement protobuf reflection instead. type JSONPBUnmarshaler interface { UnmarshalJSONPB(Unmarshaler, []byte) error } // Unmarshal unmarshals a JSON object from r into m. func (u Unmarshaler) Unmarshal(r io.Reader, m proto.Message) error { return u.UnmarshalNext(json.NewDecoder(r), m) } // UnmarshalNext unmarshals the next JSON object from d into m. func (u Unmarshaler) UnmarshalNext(d json.Decoder, m proto.Message) error { if m == nil { return errors.New("invalid nil message") } // Parse the next JSON object from the stream. raw := json.RawMessage{} if err := d.Decode(&raw); err != nil { return err } // Check for custom unmarshalers first since they may not properly // implement protobuf reflection that the logic below relies on. if jsu, ok := m.(JSONPBUnmarshaler); ok { return jsu.UnmarshalJSONPB(u, raw) } mr := proto.MessageReflect(m) // NOTE: For historical reasons, a top-level null is treated as a noop. // This is incorrect, but kept for compatibility. if string(raw) == "null" && mr.Descriptor().FullName() != "google.protobuf.Value" { return nil } if wrapJSONUnmarshalV2 { // NOTE: If input message is non-empty, we need to preserve merge semantics // of the old jsonpb implementation. These semantics are not supported by // the protobuf JSON specification. isEmpty := true mr.Range(func(protoreflect.FieldDescriptor, protoreflect.Value) bool { isEmpty = false // at least one iteration implies non-empty return false }) if !isEmpty { // Perform unmarshaling into a newly allocated, empty message. mr = mr.New() // Use a defer to copy all unmarshaled fields into the original message. dst := proto.MessageReflect(m) defer mr.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { dst.Set(fd, v) return true }) } // Unmarshal using the v2 JSON unmarshaler. opts := protojson.UnmarshalOptions{ DiscardUnknown: u.AllowUnknownFields, } if u.AnyResolver != nil { opts.Resolver = anyResolver{u.AnyResolver} } return opts.Unmarshal(raw, mr.Interface()) } else { if err := u.unmarshalMessage(mr, raw); err != nil { return err } return protoV2.CheckInitialized(mr.Interface()) } } func (u Unmarshaler) unmarshalMessage(m protoreflect.Message, in []byte) error { md := m.Descriptor() fds := md.Fields() if jsu, ok := proto.MessageV1(m.Interface()).(JSONPBUnmarshaler); ok { return jsu.UnmarshalJSONPB(u, in) } if string(in) == "null" && md.FullName() != "google.protobuf.Value" { return nil } switch wellKnownType(md.FullName()) { case "Any": var jsonObject map[string]json.RawMessage if err := json.Unmarshal(in, &jsonObject); err != nil { return err } rawTypeURL, ok := jsonObject["@type"] if !ok { return errors.New("Any JSON doesn't have '@type'") } typeURL, err := unquoteString(string(rawTypeURL)) if err != nil { return fmt.Errorf("can't unmarshal Any's '@type': %q", rawTypeURL) } m.Set(fds.ByNumber(1), protoreflect.ValueOfString(typeURL)) var m2 protoreflect.Message if u.AnyResolver != nil { mi, err := u.AnyResolver.Resolve(typeURL) if err != nil { return err } m2 = proto.MessageReflect(mi) } else { mt, err := protoregistry.GlobalTypes.FindMessageByURL(typeURL) if err != nil { if err == protoregistry.NotFound { return fmt.Errorf("could not resolve Any message type: %v", typeURL) } return err } m2 = mt.New() } if wellKnownType(m2.Descriptor().FullName()) != "" { rawValue, ok := jsonObject["value"] if !ok { return errors.New("Any JSON doesn't have 'value'") } if err := u.unmarshalMessage(m2, rawValue); err != nil { return fmt.Errorf("can't unmarshal Any nested proto %v: %v", typeURL, err) } } else { delete(jsonObject, "@type") rawJSON, err := json.Marshal(jsonObject) if err != nil { return fmt.Errorf("can't generate JSON for Any's nested proto to be unmarshaled: %v", err) } if err = u.unmarshalMessage(m2, rawJSON); err != nil { return fmt.Errorf("can't unmarshal Any nested proto %v: %v", typeURL, err) } } rawWire, err := protoV2.Marshal(m2.Interface()) if err != nil { return fmt.Errorf("can't marshal proto %v into Any.Value: %v", typeURL, err) } m.Set(fds.ByNumber(2), protoreflect.ValueOfBytes(rawWire)) return nil case "BoolValue", "BytesValue", "StringValue", "Int32Value", "UInt32Value", "FloatValue", "Int64Value", "UInt64Value", "DoubleValue": fd := fds.ByNumber(1) v, err := u.unmarshalValue(m.NewField(fd), in, fd) if err != nil { return err } m.Set(fd, v) return nil case "Duration": v, err := unquoteString(string(in)) if err != nil { return err } d, err := time.ParseDuration(v) if err != nil { return fmt.Errorf("bad Duration: %v", err) } sec := d.Nanoseconds() / 1e9 nsec := d.Nanoseconds() % 1e9 m.Set(fds.ByNumber(1), protoreflect.ValueOfInt64(int64(sec))) m.Set(fds.ByNumber(2), protoreflect.ValueOfInt32(int32(nsec))) return nil case "Timestamp": v, err := unquoteString(string(in)) if err != nil { return err } t, err := time.Parse(time.RFC3339Nano, v) if err != nil { return fmt.Errorf("bad Timestamp: %v", err) } sec := t.Unix() nsec := t.Nanosecond() m.Set(fds.ByNumber(1), protoreflect.ValueOfInt64(int64(sec))) m.Set(fds.ByNumber(2), protoreflect.ValueOfInt32(int32(nsec))) return nil case "Value": switch { case string(in) == "null": m.Set(fds.ByNumber(1), protoreflect.ValueOfEnum(0)) case string(in) == "true": m.Set(fds.ByNumber(4), protoreflect.ValueOfBool(true)) case string(in) == "false": m.Set(fds.ByNumber(4), protoreflect.ValueOfBool(false)) case hasPrefixAndSuffix('"', in, '"'): s, err := unquoteString(string(in)) if err != nil { return fmt.Errorf("unrecognized type for Value %q", in) } m.Set(fds.ByNumber(3), protoreflect.ValueOfString(s)) case hasPrefixAndSuffix('[', in, ']'): v := m.Mutable(fds.ByNumber(6)) return u.unmarshalMessage(v.Message(), in) case hasPrefixAndSuffix('{', in, '}'): v := m.Mutable(fds.ByNumber(5)) return u.unmarshalMessage(v.Message(), in) default: f, err := strconv.ParseFloat(string(in), 0) if err != nil { return fmt.Errorf("unrecognized type for Value %q", in) } m.Set(fds.ByNumber(2), protoreflect.ValueOfFloat64(f)) } return nil case "ListValue": var jsonArray []json.RawMessage if err := json.Unmarshal(in, &jsonArray); err != nil { return fmt.Errorf("bad ListValue: %v", err) } lv := m.Mutable(fds.ByNumber(1)).List() for _, raw := range jsonArray { ve := lv.NewElement() if err := u.unmarshalMessage(ve.Message(), raw); err != nil { return err } lv.Append(ve) } return nil case "Struct": var jsonObject map[string]json.RawMessage if err := json.Unmarshal(in, &jsonObject); err != nil { return fmt.Errorf("bad StructValue: %v", err) } mv := m.Mutable(fds.ByNumber(1)).Map() for key, raw := range jsonObject { kv := protoreflect.ValueOf(key).MapKey() vv := mv.NewValue() if err := u.unmarshalMessage(vv.Message(), raw); err != nil { return fmt.Errorf("bad value in StructValue for key %q: %v", key, err) } mv.Set(kv, vv) } return nil } var jsonObject map[string]json.RawMessage if err := json.Unmarshal(in, &jsonObject); err != nil { return err } // Handle known fields. for i := 0; i < fds.Len(); i++ { fd := fds.Get(i) if fd.IsWeak() && fd.Message().IsPlaceholder() { continue // weak reference is not linked in } // Search for any raw JSON value associated with this field. var raw json.RawMessage name := string(fd.Name()) if fd.Kind() == protoreflect.GroupKind { name = string(fd.Message().Name()) } if v, ok := jsonObject[name]; ok { delete(jsonObject, name) raw = v } name = string(fd.JSONName()) if v, ok := jsonObject[name]; ok { delete(jsonObject, name) raw = v } field := m.NewField(fd) // Unmarshal the field value. if raw == nil \|\| (string(raw) == "null" && !isSingularWellKnownValue(fd) && !isSingularJSONPBUnmarshaler(field, fd)) { continue } v, err := u.unmarshalValue(field, raw, fd) if err != nil { return err } m.Set(fd, v) } // Handle extension fields. for name, raw := range jsonObject { if !strings.HasPrefix(name, "[") \|\| !strings.HasSuffix(name, "]") { continue } // Resolve the extension field by name. xname := protoreflect.FullName(name[len("[") : len(name)-len("]")]) xt, _ := protoregistry.GlobalTypes.FindExtensionByName(xname) if xt == nil && isMessageSet(md) { xt, _ = protoregistry.GlobalTypes.FindExtensionByName(xname.Append("message_set_extension")) } if xt == nil { continue } delete(jsonObject, name) fd := xt.TypeDescriptor() if fd.ContainingMessage().FullName() != m.Descriptor().FullName() { return fmt.Errorf("extension field %q does not extend message %q", xname, m.Descriptor().FullName()) } field := m.NewField(fd) // Unmarshal the field value. if raw == nil \|\| (string(raw) == "null" && !isSingularWellKnownValue(fd) && !isSingularJSONPBUnmarshaler(field, fd)) { continue } v, err := u.unmarshalValue(field, raw, fd) if err != nil { return err } m.Set(fd, v) } if !u.AllowUnknownFields && len(jsonObject) > 0 { for name := range jsonObject { return fmt.Errorf("unknown field %q in %v", name, md.FullName()) } } return nil } func isSingularWellKnownValue(fd protoreflect.FieldDescriptor) bool { if fd.Cardinality() == protoreflect.Repeated { return false } if md := fd.Message(); md != nil { return md.FullName() == "google.protobuf.Value" } if ed := fd.Enum(); ed != nil { return ed.FullName() == "google.protobuf.NullValue" } return false } func isSingularJSONPBUnmarshaler(v protoreflect.Value, fd protoreflect.FieldDescriptor) bool { if fd.Message() != nil && fd.Cardinality() != protoreflect.Repeated { _, ok := proto.MessageV1(v.Interface()).(JSONPBUnmarshaler) return ok } return false } func (u Unmarshaler) unmarshalValue(v protoreflect.Value, in []byte, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) { switch { case fd.IsList(): var jsonArray []json.RawMessage if err := json.Unmarshal(in, &jsonArray); err != nil { return v, err } lv := v.List() for _, raw := range jsonArray { ve, err := u.unmarshalSingularValue(lv.NewElement(), raw, fd) if err != nil { return v, err } lv.Append(ve) } return v, nil case fd.IsMap(): var jsonObject map[string]json.RawMessage if err := json.Unmarshal(in, &jsonObject); err != nil { return v, err } kfd := fd.MapKey() vfd := fd.MapValue() mv := v.Map() for key, raw := range jsonObject { var kv protoreflect.MapKey if kfd.Kind() == protoreflect.StringKind { kv = protoreflect.ValueOf(key).MapKey() } else { v, err := u.unmarshalSingularValue(kfd.Default(), []byte(key), kfd) if err != nil { return v, err } kv = v.MapKey() } vv, err := u.unmarshalSingularValue(mv.NewValue(), raw, vfd) if err != nil { return v, err } mv.Set(kv, vv) } return v, nil default: return u.unmarshalSingularValue(v, in, fd) } } var nonFinite = map[string]float64{ `"NaN"`: math.NaN(), `"Infinity"`: math.Inf(+1), `"-Infinity"`: math.Inf(-1), } func (u Unmarshaler) unmarshalSingularValue(v protoreflect.Value, in []byte, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) { switch fd.Kind() { case protoreflect.BoolKind: return unmarshalValue(in, new(bool)) case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind: return unmarshalValue(trimQuote(in), new(int32)) case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind: return unmarshalValue(trimQuote(in), new(int64)) case protoreflect.Uint32Kind, protoreflect.Fixed32Kind: return unmarshalValue(trimQuote(in), new(uint32)) case protoreflect.Uint64Kind, protoreflect.Fixed64Kind: return unmarshalValue(trimQuote(in), new(uint64)) case protoreflect.FloatKind: if f, ok := nonFinite[string(in)]; ok { return protoreflect.ValueOfFloat32(float32(f)), nil } return unmarshalValue(trimQuote(in), new(float32)) case protoreflect.DoubleKind: if f, ok := nonFinite[string(in)]; ok { return protoreflect.ValueOfFloat64(float64(f)), nil } return unmarshalValue(trimQuote(in), new(float64)) case protoreflect.StringKind: return unmarshalValue(in, new(string)) case protoreflect.BytesKind: return unmarshalValue(in, new([]byte)) case protoreflect.EnumKind: if hasPrefixAndSuffix('"', in, '"') { vd := fd.Enum().Values().ByName(protoreflect.Name(trimQuote(in))) if vd == nil { return v, fmt.Errorf("unknown value %q for enum %s", in, fd.Enum().FullName()) } return protoreflect.ValueOfEnum(vd.Number()), nil } return unmarshalValue(in, new(protoreflect.EnumNumber)) case protoreflect.MessageKind, protoreflect.GroupKind: err := u.unmarshalMessage(v.Message(), in) return v, err default: panic(fmt.Sprintf("invalid kind %v", fd.Kind())) } } func unmarshalValue(in []byte, v interface{}) (protoreflect.Value, error) { err := json.Unmarshal(in, v) return protoreflect.ValueOf(reflect.ValueOf(v).Elem().Interface()), err } func unquoteString(in string) (out string, err error) { err = json.Unmarshal([]byte(in), &out) return out, err } func hasPrefixAndSuffix(prefix byte, in []byte, suffix byte) bool { if len(in) >= 2 && in[0] == prefix && in[len(in)-1] == suffix { return true } return false } // trimQuote is like unquoteString but simply strips surrounding quotes. // This is incorrect, but is behavior done by the legacy implementation. func trimQuote(in []byte) []byte { if len(in) >= 2 && in[0] == '"' && in[len(in)-1] == '"' { in = in[1 : len(in)-1] } return in }	15.43 KB	2025-05-25 12:27
📄 encode.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package jsonpb import ( "encoding/json" "errors" "fmt" "io" "math" "reflect" "sort" "strconv" "strings" "time" "github.com/golang/protobuf/proto" "google.golang.org/protobuf/encoding/protojson" protoV2 "google.golang.org/protobuf/proto" "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoregistry" ) const wrapJSONMarshalV2 = false // Marshaler is a configurable object for marshaling protocol buffer messages // to the specified JSON representation. type Marshaler struct { // OrigName specifies whether to use the original protobuf name for fields. OrigName bool // EnumsAsInts specifies whether to render enum values as integers, // as opposed to string values. EnumsAsInts bool // EmitDefaults specifies whether to render fields with zero values. EmitDefaults bool // Indent controls whether the output is compact or not. // If empty, the output is compact JSON. Otherwise, every JSON object // entry and JSON array value will be on its own line. // Each line will be preceded by repeated copies of Indent, where the // number of copies is the current indentation depth. Indent string // AnyResolver is used to resolve the google.protobuf.Any well-known type. // If unset, the global registry is used by default. AnyResolver AnyResolver } // JSONPBMarshaler is implemented by protobuf messages that customize the // way they are marshaled to JSON. Messages that implement this should also // implement JSONPBUnmarshaler so that the custom format can be parsed. // // The JSON marshaling must follow the proto to JSON specification: // https://developers.google.com/protocol-buffers/docs/proto3#json // // Deprecated: Custom types should implement protobuf reflection instead. type JSONPBMarshaler interface { MarshalJSONPB(Marshaler) ([]byte, error) } // Marshal serializes a protobuf message as JSON into w. func (jm Marshaler) Marshal(w io.Writer, m proto.Message) error { b, err := jm.marshal(m) if len(b) > 0 { if _, err := w.Write(b); err != nil { return err } } return err } // MarshalToString serializes a protobuf message as JSON in string form. func (jm Marshaler) MarshalToString(m proto.Message) (string, error) { b, err := jm.marshal(m) if err != nil { return "", err } return string(b), nil } func (jm Marshaler) marshal(m proto.Message) ([]byte, error) { v := reflect.ValueOf(m) if m == nil \|\| (v.Kind() == reflect.Ptr && v.IsNil()) { return nil, errors.New("Marshal called with nil") } // Check for custom marshalers first since they may not properly // implement protobuf reflection that the logic below relies on. if jsm, ok := m.(JSONPBMarshaler); ok { return jsm.MarshalJSONPB(jm) } if wrapJSONMarshalV2 { opts := protojson.MarshalOptions{ UseProtoNames: jm.OrigName, UseEnumNumbers: jm.EnumsAsInts, EmitUnpopulated: jm.EmitDefaults, Indent: jm.Indent, } if jm.AnyResolver != nil { opts.Resolver = anyResolver{jm.AnyResolver} } return opts.Marshal(proto.MessageReflect(m).Interface()) } else { // Check for unpopulated required fields first. m2 := proto.MessageReflect(m) if err := protoV2.CheckInitialized(m2.Interface()); err != nil { return nil, err } w := jsonWriter{Marshaler: jm} err := w.marshalMessage(m2, "", "") return w.buf, err } } type jsonWriter struct { Marshaler buf []byte } func (w jsonWriter) write(s string) { w.buf = append(w.buf, s...) } func (w jsonWriter) marshalMessage(m protoreflect.Message, indent, typeURL string) error { if jsm, ok := proto.MessageV1(m.Interface()).(JSONPBMarshaler); ok { b, err := jsm.MarshalJSONPB(w.Marshaler) if err != nil { return err } if typeURL != "" { // we are marshaling this object to an Any type var js map[string]json.RawMessage if err = json.Unmarshal(b, &js); err != nil { return fmt.Errorf("type %T produced invalid JSON: %v", m.Interface(), err) } turl, err := json.Marshal(typeURL) if err != nil { return fmt.Errorf("failed to marshal type URL %q to JSON: %v", typeURL, err) } js["@type"] = (json.RawMessage)(&turl) if b, err = json.Marshal(js); err != nil { return err } } w.write(string(b)) return nil } md := m.Descriptor() fds := md.Fields() // Handle well-known types. const secondInNanos = int64(time.Second / time.Nanosecond) switch wellKnownType(md.FullName()) { case "Any": return w.marshalAny(m, indent) case "BoolValue", "BytesValue", "StringValue", "Int32Value", "UInt32Value", "FloatValue", "Int64Value", "UInt64Value", "DoubleValue": fd := fds.ByNumber(1) return w.marshalValue(fd, m.Get(fd), indent) case "Duration": const maxSecondsInDuration = 315576000000 // "Generated output always contains 0, 3, 6, or 9 fractional digits, // depending on required precision." s := m.Get(fds.ByNumber(1)).Int() ns := m.Get(fds.ByNumber(2)).Int() if s < -maxSecondsInDuration \|\| s > maxSecondsInDuration { return fmt.Errorf("seconds out of range %v", s) } if ns <= -secondInNanos \|\| ns >= secondInNanos { return fmt.Errorf("ns out of range (%v, %v)", -secondInNanos, secondInNanos) } if (s > 0 && ns < 0) \|\| (s < 0 && ns > 0) { return errors.New("signs of seconds and nanos do not match") } var sign string if s < 0 \|\| ns < 0 { sign, s, ns = "-", -1s, -1ns } x := fmt.Sprintf("%s%d.%09d", sign, s, ns) x = strings.TrimSuffix(x, "000") x = strings.TrimSuffix(x, "000") x = strings.TrimSuffix(x, ".000") w.write(fmt.Sprintf(`"%vs"`, x)) return nil case "Timestamp": // "RFC 3339, where generated output will always be Z-normalized // and uses 0, 3, 6 or 9 fractional digits." s := m.Get(fds.ByNumber(1)).Int() ns := m.Get(fds.ByNumber(2)).Int() if ns < 0 \|\| ns >= secondInNanos { return fmt.Errorf("ns out of range [0, %v)", secondInNanos) } t := time.Unix(s, ns).UTC() // time.RFC3339Nano isn't exactly right (we need to get 3/6/9 fractional digits). x := t.Format("2006-01-02T15:04:05.000000000") x = strings.TrimSuffix(x, "000") x = strings.TrimSuffix(x, "000") x = strings.TrimSuffix(x, ".000") w.write(fmt.Sprintf(`"%vZ"`, x)) return nil case "Value": // JSON value; which is a null, number, string, bool, object, or array. od := md.Oneofs().Get(0) fd := m.WhichOneof(od) if fd == nil { return errors.New("nil Value") } return w.marshalValue(fd, m.Get(fd), indent) case "Struct", "ListValue": // JSON object or array. fd := fds.ByNumber(1) return w.marshalValue(fd, m.Get(fd), indent) } w.write("{") if w.Indent != "" { w.write("\n") } firstField := true if typeURL != "" { if err := w.marshalTypeURL(indent, typeURL); err != nil { return err } firstField = false } for i := 0; i < fds.Len(); { fd := fds.Get(i) if od := fd.ContainingOneof(); od != nil { fd = m.WhichOneof(od) i += od.Fields().Len() if fd == nil { continue } } else { i++ } v := m.Get(fd) if !m.Has(fd) { if !w.EmitDefaults \|\| fd.ContainingOneof() != nil { continue } if fd.Cardinality() != protoreflect.Repeated && (fd.Message() != nil \|\| fd.Syntax() == protoreflect.Proto2) { v = protoreflect.Value{} // use "null" for singular messages or proto2 scalars } } if !firstField { w.writeComma() } if err := w.marshalField(fd, v, indent); err != nil { return err } firstField = false } // Handle proto2 extensions. if md.ExtensionRanges().Len() > 0 { // Collect a sorted list of all extension descriptor and values. type ext struct { desc protoreflect.FieldDescriptor val protoreflect.Value } var exts []ext m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { if fd.IsExtension() { exts = append(exts, ext{fd, v}) } return true }) sort.Slice(exts, func(i, j int) bool { return exts[i].desc.Number() < exts[j].desc.Number() }) for _, ext := range exts { if !firstField { w.writeComma() } if err := w.marshalField(ext.desc, ext.val, indent); err != nil { return err } firstField = false } } if w.Indent != "" { w.write("\n") w.write(indent) } w.write("}") return nil } func (w jsonWriter) writeComma() { if w.Indent != "" { w.write(",\n") } else { w.write(",") } } func (w jsonWriter) marshalAny(m protoreflect.Message, indent string) error { // "If the Any contains a value that has a special JSON mapping, // it will be converted as follows: {"@type": xxx, "value": yyy}. // Otherwise, the value will be converted into a JSON object, // and the "@type" field will be inserted to indicate the actual data type." md := m.Descriptor() typeURL := m.Get(md.Fields().ByNumber(1)).String() rawVal := m.Get(md.Fields().ByNumber(2)).Bytes() var m2 protoreflect.Message if w.AnyResolver != nil { mi, err := w.AnyResolver.Resolve(typeURL) if err != nil { return err } m2 = proto.MessageReflect(mi) } else { mt, err := protoregistry.GlobalTypes.FindMessageByURL(typeURL) if err != nil { return err } m2 = mt.New() } if err := protoV2.Unmarshal(rawVal, m2.Interface()); err != nil { return err } if wellKnownType(m2.Descriptor().FullName()) == "" { return w.marshalMessage(m2, indent, typeURL) } w.write("{") if w.Indent != "" { w.write("\n") } if err := w.marshalTypeURL(indent, typeURL); err != nil { return err } w.writeComma() if w.Indent != "" { w.write(indent) w.write(w.Indent) w.write(`"value": `) } else { w.write(`"value":`) } if err := w.marshalMessage(m2, indent+w.Indent, ""); err != nil { return err } if w.Indent != "" { w.write("\n") w.write(indent) } w.write("}") return nil } func (w jsonWriter) marshalTypeURL(indent, typeURL string) error { if w.Indent != "" { w.write(indent) w.write(w.Indent) } w.write(`"@type":`) if w.Indent != "" { w.write(" ") } b, err := json.Marshal(typeURL) if err != nil { return err } w.write(string(b)) return nil } // marshalField writes field description and value to the Writer. func (w jsonWriter) marshalField(fd protoreflect.FieldDescriptor, v protoreflect.Value, indent string) error { if w.Indent != "" { w.write(indent) w.write(w.Indent) } w.write(`"`) switch { case fd.IsExtension(): // For message set, use the fname of the message as the extension name. name := string(fd.FullName()) if isMessageSet(fd.ContainingMessage()) { name = strings.TrimSuffix(name, ".message_set_extension") } w.write("[" + name + "]") case w.OrigName: name := string(fd.Name()) if fd.Kind() == protoreflect.GroupKind { name = string(fd.Message().Name()) } w.write(name) default: w.write(string(fd.JSONName())) } w.write(`":`) if w.Indent != "" { w.write(" ") } return w.marshalValue(fd, v, indent) } func (w jsonWriter) marshalValue(fd protoreflect.FieldDescriptor, v protoreflect.Value, indent string) error { switch { case fd.IsList(): w.write("[") comma := "" lv := v.List() for i := 0; i < lv.Len(); i++ { w.write(comma) if w.Indent != "" { w.write("\n") w.write(indent) w.write(w.Indent) w.write(w.Indent) } if err := w.marshalSingularValue(fd, lv.Get(i), indent+w.Indent); err != nil { return err } comma = "," } if w.Indent != "" { w.write("\n") w.write(indent) w.write(w.Indent) } w.write("]") return nil case fd.IsMap(): kfd := fd.MapKey() vfd := fd.MapValue() mv := v.Map() // Collect a sorted list of all map keys and values. type entry struct{ key, val protoreflect.Value } var entries []entry mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool { entries = append(entries, entry{k.Value(), v}) return true }) sort.Slice(entries, func(i, j int) bool { switch kfd.Kind() { case protoreflect.BoolKind: return !entries[i].key.Bool() && entries[j].key.Bool() case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind: return entries[i].key.Int() < entries[j].key.Int() case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind: return entries[i].key.Uint() < entries[j].key.Uint() case protoreflect.StringKind: return entries[i].key.String() < entries[j].key.String() default: panic("invalid kind") } }) w.write(`{`) comma := "" for _, entry := range entries { w.write(comma) if w.Indent != "" { w.write("\n") w.write(indent) w.write(w.Indent) w.write(w.Indent) } s := fmt.Sprint(entry.key.Interface()) b, err := json.Marshal(s) if err != nil { return err } w.write(string(b)) w.write(`:`) if w.Indent != "" { w.write(` `) } if err := w.marshalSingularValue(vfd, entry.val, indent+w.Indent); err != nil { return err } comma = "," } if w.Indent != "" { w.write("\n") w.write(indent) w.write(w.Indent) } w.write(`}`) return nil default: return w.marshalSingularValue(fd, v, indent) } } func (w *jsonWriter) marshalSingularValue(fd protoreflect.FieldDescriptor, v protoreflect.Value, indent string) error { switch { case !v.IsValid(): w.write("null") return nil case fd.Message() != nil: return w.marshalMessage(v.Message(), indent+w.Indent, "") case fd.Enum() != nil: if fd.Enum().FullName() == "google.protobuf.NullValue" { w.write("null") return nil } vd := fd.Enum().Values().ByNumber(v.Enum()) if vd == nil \|\| w.EnumsAsInts { w.write(strconv.Itoa(int(v.Enum()))) } else { w.write(`"` + string(vd.Name()) + `"`) } return nil default: switch v.Interface().(type) { case float32, float64: switch { case math.IsInf(v.Float(), +1): w.write(`"Infinity"`) return nil case math.IsInf(v.Float(), -1): w.write(`"-Infinity"`) return nil case math.IsNaN(v.Float()): w.write(`"NaN"`) return nil } case int64, uint64: w.write(fmt.Sprintf(`"%d"`, v.Interface())) return nil } b, err := json.Marshal(v.Interface()) if err != nil { return err } w.write(string(b)) return nil } }	14.02 KB	2025-05-25 12:27
📄 json.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package jsonpb provides functionality to marshal and unmarshal between a // protocol buffer message and JSON. It follows the specification at // https://developers.google.com/protocol-buffers/docs/proto3#json. // // Do not rely on the default behavior of the standard encoding/json package // when called on generated message types as it does not operate correctly. // // Deprecated: Use the "google.golang.org/protobuf/encoding/protojson" // package instead. package jsonpb import ( "github.com/golang/protobuf/proto" "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/runtime/protoimpl" ) // AnyResolver takes a type URL, present in an Any message, // and resolves it into an instance of the associated message. type AnyResolver interface { Resolve(typeURL string) (proto.Message, error) } type anyResolver struct{ AnyResolver } func (r anyResolver) FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error) { return r.FindMessageByURL(string(message)) } func (r anyResolver) FindMessageByURL(url string) (protoreflect.MessageType, error) { m, err := r.Resolve(url) if err != nil { return nil, err } return protoimpl.X.MessageTypeOf(m), nil } func (r anyResolver) FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) { return protoregistry.GlobalTypes.FindExtensionByName(field) } func (r anyResolver) FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) { return protoregistry.GlobalTypes.FindExtensionByNumber(message, field) } func wellKnownType(s protoreflect.FullName) string { if s.Parent() == "google.protobuf" { switch s.Name() { case "Empty", "Any", "BoolValue", "BytesValue", "StringValue", "Int32Value", "UInt32Value", "FloatValue", "Int64Value", "UInt64Value", "DoubleValue", "Duration", "Timestamp", "NullValue", "Struct", "Value", "ListValue": return string(s.Name()) } } return "" } func isMessageSet(md protoreflect.MessageDescriptor) bool { ms, ok := md.(interface{ IsMessageSet() bool }) return ok && ms.IsMessageSet() }	2.3 KB	2025-05-25 12:27
📄 json_test.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package jsonpb import ( "bytes" "compress/gzip" "encoding/json" "io" "math" "reflect" "strings" "testing" "github.com/golang/protobuf/proto" "github.com/golang/protobuf/ptypes" pb2 "github.com/golang/protobuf/internal/testprotos/jsonpb_proto" pb3 "github.com/golang/protobuf/internal/testprotos/proto3_proto" descpb "github.com/golang/protobuf/protoc-gen-go/descriptor" anypb "github.com/golang/protobuf/ptypes/any" durpb "github.com/golang/protobuf/ptypes/duration" stpb "github.com/golang/protobuf/ptypes/struct" tspb "github.com/golang/protobuf/ptypes/timestamp" wpb "github.com/golang/protobuf/ptypes/wrappers" ) var ( marshaler = Marshaler{} marshalerAllOptions = Marshaler{ Indent: " ", } simpleObject = &pb2.Simple{ OInt32: proto.Int32(-32), OInt32Str: proto.Int32(-32), OInt64: proto.Int64(-6400000000), OInt64Str: proto.Int64(-6400000000), OUint32: proto.Uint32(32), OUint32Str: proto.Uint32(32), OUint64: proto.Uint64(6400000000), OUint64Str: proto.Uint64(6400000000), OSint32: proto.Int32(-13), OSint32Str: proto.Int32(-13), OSint64: proto.Int64(-2600000000), OSint64Str: proto.Int64(-2600000000), OFloat: proto.Float32(3.14), OFloatStr: proto.Float32(3.14), ODouble: proto.Float64(6.02214179e23), ODoubleStr: proto.Float64(6.02214179e23), OBool: proto.Bool(true), OString: proto.String("hello \"there\""), OBytes: []byte("beep boop"), } simpleObjectInputJSON = `{` + `"oBool":true,` + `"oInt32":-32,` + `"oInt32Str":"-32",` + `"oInt64":-6400000000,` + `"oInt64Str":"-6400000000",` + `"oUint32":32,` + `"oUint32Str":"32",` + `"oUint64":6400000000,` + `"oUint64Str":"6400000000",` + `"oSint32":-13,` + `"oSint32Str":"-13",` + `"oSint64":-2600000000,` + `"oSint64Str":"-2600000000",` + `"oFloat":3.14,` + `"oFloatStr":"3.14",` + `"oDouble":6.02214179e+23,` + `"oDoubleStr":"6.02214179e+23",` + `"oString":"hello \"there\"",` + `"oBytes":"YmVlcCBib29w"` + `}` simpleObjectOutputJSON = `{` + `"oBool":true,` + `"oInt32":-32,` + `"oInt32Str":-32,` + `"oInt64":"-6400000000",` + `"oInt64Str":"-6400000000",` + `"oUint32":32,` + `"oUint32Str":32,` + `"oUint64":"6400000000",` + `"oUint64Str":"6400000000",` + `"oSint32":-13,` + `"oSint32Str":-13,` + `"oSint64":"-2600000000",` + `"oSint64Str":"-2600000000",` + `"oFloat":3.14,` + `"oFloatStr":3.14,` + `"oDouble":6.02214179e+23,` + `"oDoubleStr":6.02214179e+23,` + `"oString":"hello \"there\"",` + `"oBytes":"YmVlcCBib29w"` + `}` simpleObjectInputPrettyJSON = `{ "oBool": true, "oInt32": -32, "oInt32Str": "-32", "oInt64": -6400000000, "oInt64Str": "-6400000000", "oUint32": 32, "oUint32Str": "32", "oUint64": 6400000000, "oUint64Str": "6400000000", "oSint32": -13, "oSint32Str": "-13", "oSint64": -2600000000, "oSint64Str": "-2600000000", "oFloat": 3.14, "oFloatStr": "3.14", "oDouble": 6.02214179e+23, "oDoubleStr": "6.02214179e+23", "oString": "hello \"there\"", "oBytes": "YmVlcCBib29w" }` simpleObjectOutputPrettyJSON = `{ "oBool": true, "oInt32": -32, "oInt32Str": -32, "oInt64": "-6400000000", "oInt64Str": "-6400000000", "oUint32": 32, "oUint32Str": 32, "oUint64": "6400000000", "oUint64Str": "6400000000", "oSint32": -13, "oSint32Str": -13, "oSint64": "-2600000000", "oSint64Str": "-2600000000", "oFloat": 3.14, "oFloatStr": 3.14, "oDouble": 6.02214179e+23, "oDoubleStr": 6.02214179e+23, "oString": "hello \"there\"", "oBytes": "YmVlcCBib29w" }` repeatsObject = &pb2.Repeats{ RBool: []bool{true, false, true}, RInt32: []int32{-3, -4, -5}, RInt64: []int64{-123456789, -987654321}, RUint32: []uint32{1, 2, 3}, RUint64: []uint64{6789012345, 3456789012}, RSint32: []int32{-1, -2, -3}, RSint64: []int64{-6789012345, -3456789012}, RFloat: []float32{3.14, 6.28}, RDouble: []float64{299792458 * 1e20, 6.62606957e-34}, RString: []string{"happy", "days"}, RBytes: [][]byte{[]byte("skittles"), []byte("m&m's")}, } repeatsObjectJSON = `{` + `"rBool":[true,false,true],` + `"rInt32":[-3,-4,-5],` + `"rInt64":["-123456789","-987654321"],` + `"rUint32":[1,2,3],` + `"rUint64":["6789012345","3456789012"],` + `"rSint32":[-1,-2,-3],` + `"rSint64":["-6789012345","-3456789012"],` + `"rFloat":[3.14,6.28],` + `"rDouble":[2.99792458e+28,6.62606957e-34],` + `"rString":["happy","days"],` + `"rBytes":["c2tpdHRsZXM=","bSZtJ3M="]` + `}` repeatsObjectPrettyJSON = `{ "rBool": [ true, false, true ], "rInt32": [ -3, -4, -5 ], "rInt64": [ "-123456789", "-987654321" ], "rUint32": [ 1, 2, 3 ], "rUint64": [ "6789012345", "3456789012" ], "rSint32": [ -1, -2, -3 ], "rSint64": [ "-6789012345", "-3456789012" ], "rFloat": [ 3.14, 6.28 ], "rDouble": [ 2.99792458e+28, 6.62606957e-34 ], "rString": [ "happy", "days" ], "rBytes": [ "c2tpdHRsZXM=", "bSZtJ3M=" ] }` innerSimple = &pb2.Simple{OInt32: proto.Int32(-32)} innerSimple2 = &pb2.Simple{OInt64: proto.Int64(25)} innerRepeats = &pb2.Repeats{RString: []string{"roses", "red"}} innerRepeats2 = &pb2.Repeats{RString: []string{"violets", "blue"}} complexObject = &pb2.Widget{ Color: pb2.Widget_GREEN.Enum(), RColor: []pb2.Widget_Color{pb2.Widget_RED, pb2.Widget_GREEN, pb2.Widget_BLUE}, Simple: innerSimple, RSimple: []pb2.Simple{innerSimple, innerSimple2}, Repeats: innerRepeats, RRepeats: []pb2.Repeats{innerRepeats, innerRepeats2}, } complexObjectJSON = `{"color":"GREEN",` + `"rColor":["RED","GREEN","BLUE"],` + `"simple":{"oInt32":-32},` + `"rSimple":[{"oInt32":-32},{"oInt64":"25"}],` + `"repeats":{"rString":["roses","red"]},` + `"rRepeats":[{"rString":["roses","red"]},{"rString":["violets","blue"]}]` + `}` complexObjectPrettyJSON = `{ "color": "GREEN", "rColor": [ "RED", "GREEN", "BLUE" ], "simple": { "oInt32": -32 }, "rSimple": [ { "oInt32": -32 }, { "oInt64": "25" } ], "repeats": { "rString": [ "roses", "red" ] }, "rRepeats": [ { "rString": [ "roses", "red" ] }, { "rString": [ "violets", "blue" ] } ] }` colorPrettyJSON = `{ "color": 2 }` colorListPrettyJSON = `{ "color": 1000, "rColor": [ "RED" ] }` nummyPrettyJSON = `{ "nummy": { "1": 2, "3": 4 } }` objjyPrettyJSON = `{ "objjy": { "1": { "dub": 1 } } }` realNumber = &pb2.Real{Value: proto.Float64(3.14159265359)} realNumberName = "Pi" complexNumber = &pb2.Complex{Imaginary: proto.Float64(0.5772156649)} realNumberJSON = `{` + `"value":3.14159265359,` + `"[jsonpb_test.Complex.real_extension]":{"imaginary":0.5772156649},` + `"[jsonpb_test.name]":"Pi"` + `}` anySimple = &pb2.KnownTypes{ An: &anypb.Any{ TypeUrl: "something.example.com/jsonpb_test.Simple", Value: []byte{ // &pb2.Simple{OBool:true} 1 << 3, 1, }, }, } anySimpleJSON = `{"an":{"@type":"something.example.com/jsonpb_test.Simple","oBool":true}}` anySimplePrettyJSON = `{ "an": { "@type": "something.example.com/jsonpb_test.Simple", "oBool": true } }` anyWellKnown = &pb2.KnownTypes{ An: &anypb.Any{ TypeUrl: "type.googleapis.com/google.protobuf.Duration", Value: []byte{ // &durpb.Duration{Seconds: 1, Nanos: 212000000 } 1 << 3, 1, // seconds 2 << 3, 0x80, 0xba, 0x8b, 0x65, // nanos }, }, } anyWellKnownJSON = `{"an":{"@type":"type.googleapis.com/google.protobuf.Duration","value":"1.212s"}}` anyWellKnownPrettyJSON = `{ "an": { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } }` nonFinites = &pb2.NonFinites{ FNan: proto.Float32(float32(math.NaN())), FPinf: proto.Float32(float32(math.Inf(1))), FNinf: proto.Float32(float32(math.Inf(-1))), DNan: proto.Float64(float64(math.NaN())), DPinf: proto.Float64(float64(math.Inf(1))), DNinf: proto.Float64(float64(math.Inf(-1))), } nonFinitesJSON = `{` + `"fNan":"NaN",` + `"fPinf":"Infinity",` + `"fNinf":"-Infinity",` + `"dNan":"NaN",` + `"dPinf":"Infinity",` + `"dNinf":"-Infinity"` + `}` ) func init() { if err := proto.SetExtension(realNumber, pb2.E_Name, &realNumberName); err != nil { panic(err) } if err := proto.SetExtension(realNumber, pb2.E_Complex_RealExtension, complexNumber); err != nil { panic(err) } } var marshalingTests = []struct { desc string marshaler Marshaler pb proto.Message json string }{ {"simple flat object", marshaler, simpleObject, simpleObjectOutputJSON}, {"simple pretty object", marshalerAllOptions, simpleObject, simpleObjectOutputPrettyJSON}, {"non-finite floats fields object", marshaler, nonFinites, nonFinitesJSON}, {"repeated fields flat object", marshaler, repeatsObject, repeatsObjectJSON}, {"repeated fields pretty object", marshalerAllOptions, repeatsObject, repeatsObjectPrettyJSON}, {"nested message/enum flat object", marshaler, complexObject, complexObjectJSON}, {"nested message/enum pretty object", marshalerAllOptions, complexObject, complexObjectPrettyJSON}, {"enum-string flat object", Marshaler{}, &pb2.Widget{Color: pb2.Widget_BLUE.Enum()}, `{"color":"BLUE"}`}, {"enum-value pretty object", Marshaler{EnumsAsInts: true, Indent: " "}, &pb2.Widget{Color: pb2.Widget_BLUE.Enum()}, colorPrettyJSON}, {"unknown enum value object", marshalerAllOptions, &pb2.Widget{Color: pb2.Widget_Color(1000).Enum(), RColor: []pb2.Widget_Color{pb2.Widget_RED}}, colorListPrettyJSON}, {"repeated proto3 enum", Marshaler{}, &pb3.Message{RFunny: []pb3.Message_Humour{ pb3.Message_PUNS, pb3.Message_SLAPSTICK, }}, `{"rFunny":["PUNS","SLAPSTICK"]}`}, {"repeated proto3 enum as int", Marshaler{EnumsAsInts: true}, &pb3.Message{RFunny: []pb3.Message_Humour{ pb3.Message_PUNS, pb3.Message_SLAPSTICK, }}, `{"rFunny":[1,2]}`}, {"empty value", marshaler, &pb2.Simple3{}, `{}`}, {"empty value emitted", Marshaler{EmitDefaults: true}, &pb2.Simple3{}, `{"dub":0}`}, {"empty repeated emitted", Marshaler{EmitDefaults: true}, &pb2.SimpleSlice3{}, `{"slices":[]}`}, {"empty map emitted", Marshaler{EmitDefaults: true}, &pb2.SimpleMap3{}, `{"stringy":{}}`}, {"nested struct null", Marshaler{EmitDefaults: true}, &pb2.SimpleNull3{}, `{"simple":null}`}, {"map<int64, int32>", marshaler, &pb2.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}, `{"nummy":{"1":2,"3":4}}`}, {"map<int64, int32>", marshalerAllOptions, &pb2.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}, nummyPrettyJSON}, {"map<string, string>", marshaler, &pb2.Mappy{Strry: map[string]string{`"one"`: "two", "three": "four"}}, `{"strry":{"\"one\"":"two","three":"four"}}`}, {"map<int32, Object>", marshaler, &pb2.Mappy{Objjy: map[int32]pb2.Simple3{1: {Dub: 1}}}, `{"objjy":{"1":{"dub":1}}}`}, {"map<int32, Object>", marshalerAllOptions, &pb2.Mappy{Objjy: map[int32]pb2.Simple3{1: {Dub: 1}}}, objjyPrettyJSON}, {"map<int64, string>", marshaler, &pb2.Mappy{Buggy: map[int64]string{1234: "yup"}}, `{"buggy":{"1234":"yup"}}`}, {"map<bool, bool>", marshaler, &pb2.Mappy{Booly: map[bool]bool{false: true}}, `{"booly":{"false":true}}`}, {"map<string, enum>", marshaler, &pb2.Mappy{Enumy: map[string]pb2.Numeral{"XIV": pb2.Numeral_ROMAN}}, `{"enumy":{"XIV":"ROMAN"}}`}, {"map<string, enum as int>", Marshaler{EnumsAsInts: true}, &pb2.Mappy{Enumy: map[string]pb2.Numeral{"XIV": pb2.Numeral_ROMAN}}, `{"enumy":{"XIV":2}}`}, {"map<int32, bool>", marshaler, &pb2.Mappy{S32Booly: map[int32]bool{1: true, 3: false, 10: true, 12: false}}, `{"s32booly":{"1":true,"3":false,"10":true,"12":false}}`}, {"map<int64, bool>", marshaler, &pb2.Mappy{S64Booly: map[int64]bool{1: true, 3: false, 10: true, 12: false}}, `{"s64booly":{"1":true,"3":false,"10":true,"12":false}}`}, {"map<uint32, bool>", marshaler, &pb2.Mappy{U32Booly: map[uint32]bool{1: true, 3: false, 10: true, 12: false}}, `{"u32booly":{"1":true,"3":false,"10":true,"12":false}}`}, {"map<uint64, bool>", marshaler, &pb2.Mappy{U64Booly: map[uint64]bool{1: true, 3: false, 10: true, 12: false}}, `{"u64booly":{"1":true,"3":false,"10":true,"12":false}}`}, {"proto2 map<int64, string>", marshaler, &pb2.Maps{MInt64Str: map[int64]string{213: "cat"}}, `{"mInt64Str":{"213":"cat"}}`}, {"proto2 map<bool, Object>", marshaler, &pb2.Maps{MBoolSimple: map[bool]pb2.Simple{true: {OInt32: proto.Int32(1)}}}, `{"mBoolSimple":{"true":{"oInt32":1}}}`}, {"oneof, not set", marshaler, &pb2.MsgWithOneof{}, `{}`}, {"oneof, set", marshaler, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_Title{"Grand Poobah"}}, `{"title":"Grand Poobah"}`}, {"oneof NullValue", marshaler, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_NullValue{stpb.NullValue_NULL_VALUE}}, `{"nullValue":null}`}, {"force orig_name", Marshaler{OrigName: true}, &pb2.Simple{OInt32: proto.Int32(4)}, `{"o_int32":4}`}, {"proto2 extension", marshaler, realNumber, realNumberJSON}, {"Any with message", marshaler, anySimple, anySimpleJSON}, {"Any with message and indent", marshalerAllOptions, anySimple, anySimplePrettyJSON}, {"Any with WKT", marshaler, anyWellKnown, anyWellKnownJSON}, {"Any with WKT and indent", marshalerAllOptions, anyWellKnown, anyWellKnownPrettyJSON}, {"Duration empty", marshaler, &durpb.Duration{}, `"0s"`}, {"Duration with secs", marshaler, &durpb.Duration{Seconds: 3}, `"3s"`}, {"Duration with -secs", marshaler, &durpb.Duration{Seconds: -3}, `"-3s"`}, {"Duration with nanos", marshaler, &durpb.Duration{Nanos: 1e6}, `"0.001s"`}, {"Duration with -nanos", marshaler, &durpb.Duration{Nanos: -1e6}, `"-0.001s"`}, {"Duration with large secs", marshaler, &durpb.Duration{Seconds: 1e10, Nanos: 1}, `"10000000000.000000001s"`}, {"Duration with 6-digit nanos", marshaler, &durpb.Duration{Nanos: 1e4}, `"0.000010s"`}, {"Duration with 3-digit nanos", marshaler, &durpb.Duration{Nanos: 1e6}, `"0.001s"`}, {"Duration with -secs -nanos", marshaler, &durpb.Duration{Seconds: -123, Nanos: -450}, `"-123.000000450s"`}, {"Duration max value", marshaler, &durpb.Duration{Seconds: 315576000000, Nanos: 999999999}, `"315576000000.999999999s"`}, {"Duration min value", marshaler, &durpb.Duration{Seconds: -315576000000, Nanos: -999999999}, `"-315576000000.999999999s"`}, {"Struct", marshaler, &pb2.KnownTypes{St: &stpb.Struct{ Fields: map[string]stpb.Value{ "one": {Kind: &stpb.Value_StringValue{"loneliest number"}}, "two": {Kind: &stpb.Value_NullValue{stpb.NullValue_NULL_VALUE}}, }, }}, `{"st":{"one":"loneliest number","two":null}}`}, {"empty ListValue", marshaler, &pb2.KnownTypes{Lv: &stpb.ListValue{}}, `{"lv":[]}`}, {"basic ListValue", marshaler, &pb2.KnownTypes{Lv: &stpb.ListValue{Values: []stpb.Value{ {Kind: &stpb.Value_StringValue{"x"}}, {Kind: &stpb.Value_NullValue{}}, {Kind: &stpb.Value_NumberValue{3}}, {Kind: &stpb.Value_BoolValue{true}}, }}}, `{"lv":["x",null,3,true]}`}, {"Timestamp", marshaler, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 21e6}}, `{"ts":"2014-05-13T16:53:20.021Z"}`}, {"Timestamp", marshaler, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 0}}, `{"ts":"2014-05-13T16:53:20Z"}`}, {"number Value", marshaler, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_NumberValue{1}}}, `{"val":1}`}, {"null Value", marshaler, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_NullValue{stpb.NullValue_NULL_VALUE}}}, `{"val":null}`}, {"string number value", marshaler, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_StringValue{"9223372036854775807"}}}, `{"val":"9223372036854775807"}`}, {"list of lists Value", marshaler, &pb2.KnownTypes{Val: &stpb.Value{ Kind: &stpb.Value_ListValue{&stpb.ListValue{ Values: []stpb.Value{ {Kind: &stpb.Value_StringValue{"x"}}, {Kind: &stpb.Value_ListValue{&stpb.ListValue{ Values: []stpb.Value{ {Kind: &stpb.Value_ListValue{&stpb.ListValue{ Values: []stpb.Value{{Kind: &stpb.Value_StringValue{"y"}}}, }}}, {Kind: &stpb.Value_StringValue{"z"}}, }, }}}, }, }}, }}, `{"val":["x",[["y"],"z"]]}`}, {"DoubleValue", marshaler, &pb2.KnownTypes{Dbl: &wpb.DoubleValue{Value: 1.2}}, `{"dbl":1.2}`}, {"FloatValue", marshaler, &pb2.KnownTypes{Flt: &wpb.FloatValue{Value: 1.2}}, `{"flt":1.2}`}, {"Int64Value", marshaler, &pb2.KnownTypes{I64: &wpb.Int64Value{Value: -3}}, `{"i64":"-3"}`}, {"UInt64Value", marshaler, &pb2.KnownTypes{U64: &wpb.UInt64Value{Value: 3}}, `{"u64":"3"}`}, {"Int32Value", marshaler, &pb2.KnownTypes{I32: &wpb.Int32Value{Value: -4}}, `{"i32":-4}`}, {"UInt32Value", marshaler, &pb2.KnownTypes{U32: &wpb.UInt32Value{Value: 4}}, `{"u32":4}`}, {"BoolValue", marshaler, &pb2.KnownTypes{Bool: &wpb.BoolValue{Value: true}}, `{"bool":true}`}, {"StringValue", marshaler, &pb2.KnownTypes{Str: &wpb.StringValue{Value: "plush"}}, `{"str":"plush"}`}, {"BytesValue", marshaler, &pb2.KnownTypes{Bytes: &wpb.BytesValue{Value: []byte("wow")}}, `{"bytes":"d293"}`}, {"required", marshaler, &pb2.MsgWithRequired{Str: proto.String("hello")}, `{"str":"hello"}`}, {"required bytes", marshaler, &pb2.MsgWithRequiredBytes{Byts: []byte{}}, `{"byts":""}`}, } func TestMarshaling(t testing.T) { for _, tt := range marshalingTests { json, err := tt.marshaler.MarshalToString(tt.pb) if err != nil { t.Errorf("%s: marshaling error: %v", tt.desc, err) } else if tt.json != json { t.Errorf("%s:\ngot: %v\nwant: %v", tt.desc, json, tt.json) } } } func TestMarshalingNil(t testing.T) { var msg pb2.Simple m := &Marshaler{} if _, err := m.MarshalToString(msg); err == nil { t.Errorf("mashaling nil returned no error") } } func TestMarshalIllegalTime(t testing.T) { tests := []struct { pb proto.Message fail bool }{ {&durpb.Duration{Seconds: 1, Nanos: 0}, false}, {&durpb.Duration{Seconds: -1, Nanos: 0}, false}, {&durpb.Duration{Seconds: 1, Nanos: -1}, true}, {&durpb.Duration{Seconds: -1, Nanos: 1}, true}, {&durpb.Duration{Seconds: 315576000001}, true}, {&durpb.Duration{Seconds: -315576000001}, true}, {&durpb.Duration{Seconds: 1, Nanos: 1000000000}, true}, {&durpb.Duration{Seconds: -1, Nanos: -1000000000}, true}, {&tspb.Timestamp{Seconds: 1, Nanos: 1}, false}, {&tspb.Timestamp{Seconds: 1, Nanos: -1}, true}, {&tspb.Timestamp{Seconds: 1, Nanos: 1000000000}, true}, } for _, tt := range tests { _, err := marshaler.MarshalToString(tt.pb) if err == nil && tt.fail { t.Errorf("marshaler.MarshalToString(%v) = _, <nil>; want _, <non-nil>", tt.pb) } if err != nil && !tt.fail { t.Errorf("marshaler.MarshalToString(%v) = _, %v; want _, <nil>", tt.pb, err) } } } func TestMarshalJSONPBMarshaler(t testing.T) { rawJson := `{ "foo": "bar", "baz": [0, 1, 2, 3] }` msg := dynamicMessage{RawJson: rawJson} str, err := new(Marshaler).MarshalToString(&msg) if err != nil { t.Errorf("an unexpected error while marshaling JSONPBMarshaler: %v", err) } if str != rawJson { t.Errorf("marshaling JSON produced incorrect output: got %s, wanted %s", str, rawJson) } } func TestMarshalAnyJSONPBMarshaler(t testing.T) { msg := dynamicMessage{RawJson: `{ "foo": "bar", "baz": [0, 1, 2, 3] }`} a, err := ptypes.MarshalAny(&msg) if err != nil { t.Errorf("an unexpected error while marshaling to Any: %v", err) } str, err := new(Marshaler).MarshalToString(a) if err != nil { t.Errorf("an unexpected error while marshaling Any to JSON: %v", err) } // after custom marshaling, it's round-tripped through JSON decoding/encoding already, // so the keys are sorted, whitespace is compacted, and "@type" key has been added want := `{"@type":"type.googleapis.com/` + dynamicMessageName + `","baz":[0,1,2,3],"foo":"bar"}` if str != want { t.Errorf("marshaling JSON produced incorrect output: got %s, wanted %s", str, want) } } func TestMarshalWithCustomValidation(t testing.T) { msg := dynamicMessage{RawJson: `{ "foo": "bar", "baz": [0, 1, 2, 3] }`, Dummy: &dynamicMessage{}} js, err := new(Marshaler).MarshalToString(&msg) if err != nil { t.Errorf("an unexpected error while marshaling to json: %v", err) } err = Unmarshal(strings.NewReader(js), &msg) if err != nil { t.Errorf("an unexpected error while unmarshaling from json: %v", err) } } // Test marshaling message containing unset required fields should produce error. func TestMarshalUnsetRequiredFields(t testing.T) { msgExt := &pb2.Real{} proto.SetExtension(msgExt, pb2.E_Extm, &pb2.MsgWithRequired{}) tests := []struct { desc string marshaler Marshaler pb proto.Message }{ { desc: "direct required field", marshaler: &Marshaler{}, pb: &pb2.MsgWithRequired{}, }, { desc: "direct required field + emit defaults", marshaler: &Marshaler{EmitDefaults: true}, pb: &pb2.MsgWithRequired{}, }, { desc: "indirect required field", marshaler: &Marshaler{}, pb: &pb2.MsgWithIndirectRequired{Subm: &pb2.MsgWithRequired{}}, }, { desc: "indirect required field + emit defaults", marshaler: &Marshaler{EmitDefaults: true}, pb: &pb2.MsgWithIndirectRequired{Subm: &pb2.MsgWithRequired{}}, }, { desc: "direct required wkt field", marshaler: &Marshaler{}, pb: &pb2.MsgWithRequiredWKT{}, }, { desc: "direct required wkt field + emit defaults", marshaler: &Marshaler{EmitDefaults: true}, pb: &pb2.MsgWithRequiredWKT{}, }, { desc: "direct required bytes field", marshaler: &Marshaler{}, pb: &pb2.MsgWithRequiredBytes{}, }, { desc: "required in map value", marshaler: &Marshaler{}, pb: &pb2.MsgWithIndirectRequired{ MapField: map[string]pb2.MsgWithRequired{ "key": {}, }, }, }, { desc: "required in repeated item", marshaler: &Marshaler{}, pb: &pb2.MsgWithIndirectRequired{ SliceField: []pb2.MsgWithRequired{ {Str: proto.String("hello")}, {}, }, }, }, { desc: "required inside oneof", marshaler: &Marshaler{}, pb: &pb2.MsgWithOneof{ Union: &pb2.MsgWithOneof_MsgWithRequired{&pb2.MsgWithRequired{}}, }, }, { desc: "required inside extension", marshaler: &Marshaler{}, pb: msgExt, }, } for _, tc := range tests { if _, err := tc.marshaler.MarshalToString(tc.pb); err == nil { t.Errorf("%s: expected error while marshaling with unset required fields %+v", tc.desc, tc.pb) } } } var unmarshalingTests = []struct { desc string unmarshaler Unmarshaler json string pb proto.Message }{ {"simple flat object", Unmarshaler{}, simpleObjectInputJSON, simpleObject}, {"simple pretty object", Unmarshaler{}, simpleObjectInputPrettyJSON, simpleObject}, {"repeated fields flat object", Unmarshaler{}, repeatsObjectJSON, repeatsObject}, {"repeated fields pretty object", Unmarshaler{}, repeatsObjectPrettyJSON, repeatsObject}, {"nested message/enum flat object", Unmarshaler{}, complexObjectJSON, complexObject}, {"nested message/enum pretty object", Unmarshaler{}, complexObjectPrettyJSON, complexObject}, {"enum-string object", Unmarshaler{}, `{"color":"BLUE"}`, &pb2.Widget{Color: pb2.Widget_BLUE.Enum()}}, {"enum-value object", Unmarshaler{}, "{\n \"color\": 2\n}", &pb2.Widget{Color: pb2.Widget_BLUE.Enum()}}, {"unknown field with allowed option", Unmarshaler{AllowUnknownFields: true}, `{"unknown": "foo"}`, new(pb2.Simple)}, {"proto3 enum string", Unmarshaler{}, `{"hilarity":"PUNS"}`, &pb3.Message{Hilarity: pb3.Message_PUNS}}, {"proto3 enum value", Unmarshaler{}, `{"hilarity":1}`, &pb3.Message{Hilarity: pb3.Message_PUNS}}, {"unknown enum value object", Unmarshaler{}, "{\n \"color\": 1000,\n \"r_color\": [\n \"RED\"\n ]\n}", &pb2.Widget{Color: pb2.Widget_Color(1000).Enum(), RColor: []pb2.Widget_Color{pb2.Widget_RED}}}, {"repeated proto3 enum", Unmarshaler{}, `{"rFunny":["PUNS","SLAPSTICK"]}`, &pb3.Message{RFunny: []pb3.Message_Humour{ pb3.Message_PUNS, pb3.Message_SLAPSTICK, }}}, {"repeated proto3 enum as int", Unmarshaler{}, `{"rFunny":[1,2]}`, &pb3.Message{RFunny: []pb3.Message_Humour{ pb3.Message_PUNS, pb3.Message_SLAPSTICK, }}}, {"repeated proto3 enum as mix of strings and ints", Unmarshaler{}, `{"rFunny":["PUNS",2]}`, &pb3.Message{RFunny: []pb3.Message_Humour{ pb3.Message_PUNS, pb3.Message_SLAPSTICK, }}}, {"unquoted int64 object", Unmarshaler{}, `{"oInt64":-314}`, &pb2.Simple{OInt64: proto.Int64(-314)}}, {"unquoted uint64 object", Unmarshaler{}, `{"oUint64":123}`, &pb2.Simple{OUint64: proto.Uint64(123)}}, {"NaN", Unmarshaler{}, `{"oDouble":"NaN"}`, &pb2.Simple{ODouble: proto.Float64(math.NaN())}}, {"Inf", Unmarshaler{}, `{"oFloat":"Infinity"}`, &pb2.Simple{OFloat: proto.Float32(float32(math.Inf(1)))}}, {"-Inf", Unmarshaler{}, `{"oDouble":"-Infinity"}`, &pb2.Simple{ODouble: proto.Float64(math.Inf(-1))}}, {"map<int64, int32>", Unmarshaler{}, `{"nummy":{"1":2,"3":4}}`, &pb2.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}}, {"map<string, string>", Unmarshaler{}, `{"strry":{"\"one\"":"two","three":"four"}}`, &pb2.Mappy{Strry: map[string]string{`"one"`: "two", "three": "four"}}}, {"map<int32, Object>", Unmarshaler{}, `{"objjy":{"1":{"dub":1}}}`, &pb2.Mappy{Objjy: map[int32]pb2.Simple3{1: {Dub: 1}}}}, {"proto2 extension", Unmarshaler{}, realNumberJSON, realNumber}, {"Any with message", Unmarshaler{}, anySimpleJSON, anySimple}, {"Any with message and indent", Unmarshaler{}, anySimplePrettyJSON, anySimple}, {"Any with WKT", Unmarshaler{}, anyWellKnownJSON, anyWellKnown}, {"Any with WKT and indent", Unmarshaler{}, anyWellKnownPrettyJSON, anyWellKnown}, {"map<string, enum>", Unmarshaler{}, `{"enumy":{"XIV":"ROMAN"}}`, &pb2.Mappy{Enumy: map[string]pb2.Numeral{"XIV": pb2.Numeral_ROMAN}}}, {"map<string, enum as int>", Unmarshaler{}, `{"enumy":{"XIV":2}}`, &pb2.Mappy{Enumy: map[string]pb2.Numeral{"XIV": pb2.Numeral_ROMAN}}}, {"oneof", Unmarshaler{}, `{"salary":31000}`, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_Salary{31000}}}, {"oneof spec name", Unmarshaler{}, `{"Country":"Australia"}`, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_Country{"Australia"}}}, {"oneof orig_name", Unmarshaler{}, `{"Country":"Australia"}`, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_Country{"Australia"}}}, {"oneof spec name2", Unmarshaler{}, `{"homeAddress":"Australia"}`, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_HomeAddress{"Australia"}}}, {"oneof orig_name2", Unmarshaler{}, `{"home_address":"Australia"}`, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_HomeAddress{"Australia"}}}, {"oneof NullValue", Unmarshaler{}, `{"nullValue":null}`, &pb2.MsgWithOneof{Union: &pb2.MsgWithOneof_NullValue{stpb.NullValue_NULL_VALUE}}}, {"orig_name input", Unmarshaler{}, `{"o_bool":true}`, &pb2.Simple{OBool: proto.Bool(true)}}, {"camelName input", Unmarshaler{}, `{"oBool":true}`, &pb2.Simple{OBool: proto.Bool(true)}}, {"Duration", Unmarshaler{}, `{"dur":"3.000s"}`, &pb2.KnownTypes{Dur: &durpb.Duration{Seconds: 3}}}, {"Duration", Unmarshaler{}, `{"dur":"4s"}`, &pb2.KnownTypes{Dur: &durpb.Duration{Seconds: 4}}}, {"Duration with unicode", Unmarshaler{}, `{"dur": "3\u0073"}`, &pb2.KnownTypes{Dur: &durpb.Duration{Seconds: 3}}}, {"null Duration", Unmarshaler{}, `{"dur":null}`, &pb2.KnownTypes{Dur: nil}}, {"Timestamp", Unmarshaler{}, `{"ts":"2014-05-13T16:53:20.021Z"}`, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 21e6}}}, {"Timestamp", Unmarshaler{}, `{"ts":"2014-05-13T16:53:20Z"}`, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 0}}}, {"Timestamp with unicode", Unmarshaler{}, `{"ts": "2014-05-13T16:53:20\u005a"}`, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: 14e8, Nanos: 0}}}, {"PreEpochTimestamp", Unmarshaler{}, `{"ts":"1969-12-31T23:59:58.999999995Z"}`, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: -2, Nanos: 999999995}}}, {"ZeroTimeTimestamp", Unmarshaler{}, `{"ts":"0001-01-01T00:00:00Z"}`, &pb2.KnownTypes{Ts: &tspb.Timestamp{Seconds: -62135596800, Nanos: 0}}}, {"null Timestamp", Unmarshaler{}, `{"ts":null}`, &pb2.KnownTypes{Ts: nil}}, {"null Struct", Unmarshaler{}, `{"st": null}`, &pb2.KnownTypes{St: nil}}, {"empty Struct", Unmarshaler{}, `{"st": {}}`, &pb2.KnownTypes{St: &stpb.Struct{}}}, {"basic Struct", Unmarshaler{}, `{"st": {"a": "x", "b": null, "c": 3, "d": true}}`, &pb2.KnownTypes{St: &stpb.Struct{Fields: map[string]stpb.Value{ "a": {Kind: &stpb.Value_StringValue{"x"}}, "b": {Kind: &stpb.Value_NullValue{}}, "c": {Kind: &stpb.Value_NumberValue{3}}, "d": {Kind: &stpb.Value_BoolValue{true}}, }}}}, {"nested Struct", Unmarshaler{}, `{"st": {"a": {"b": 1, "c": [{"d": true}, "f"]}}}`, &pb2.KnownTypes{St: &stpb.Struct{Fields: map[string]stpb.Value{ "a": {Kind: &stpb.Value_StructValue{&stpb.Struct{Fields: map[string]stpb.Value{ "b": {Kind: &stpb.Value_NumberValue{1}}, "c": {Kind: &stpb.Value_ListValue{&stpb.ListValue{Values: []stpb.Value{ {Kind: &stpb.Value_StructValue{&stpb.Struct{Fields: map[string]stpb.Value{"d": {Kind: &stpb.Value_BoolValue{true}}}}}}, {Kind: &stpb.Value_StringValue{"f"}}, }}}}, }}}}, }}}}, {"null ListValue", Unmarshaler{}, `{"lv": null}`, &pb2.KnownTypes{Lv: nil}}, {"empty ListValue", Unmarshaler{}, `{"lv": []}`, &pb2.KnownTypes{Lv: &stpb.ListValue{}}}, {"basic ListValue", Unmarshaler{}, `{"lv": ["x", null, 3, true]}`, &pb2.KnownTypes{Lv: &stpb.ListValue{Values: []stpb.Value{ {Kind: &stpb.Value_StringValue{"x"}}, {Kind: &stpb.Value_NullValue{}}, {Kind: &stpb.Value_NumberValue{3}}, {Kind: &stpb.Value_BoolValue{true}}, }}}}, {"number Value", Unmarshaler{}, `{"val":1}`, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_NumberValue{1}}}}, {"null Value", Unmarshaler{}, `{"val":null}`, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_NullValue{stpb.NullValue_NULL_VALUE}}}}, {"bool Value", Unmarshaler{}, `{"val":true}`, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_BoolValue{true}}}}, {"string Value", Unmarshaler{}, `{"val":"x"}`, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_StringValue{"x"}}}}, {"string number value", Unmarshaler{}, `{"val":"9223372036854775807"}`, &pb2.KnownTypes{Val: &stpb.Value{Kind: &stpb.Value_StringValue{"9223372036854775807"}}}}, {"list of lists Value", Unmarshaler{}, `{"val":["x", [["y"], "z"]]}`, &pb2.KnownTypes{Val: &stpb.Value{ Kind: &stpb.Value_ListValue{&stpb.ListValue{ Values: []stpb.Value{ {Kind: &stpb.Value_StringValue{"x"}}, {Kind: &stpb.Value_ListValue{&stpb.ListValue{ Values: []stpb.Value{ {Kind: &stpb.Value_ListValue{&stpb.ListValue{ Values: []stpb.Value{{Kind: &stpb.Value_StringValue{"y"}}}, }}}, {Kind: &stpb.Value_StringValue{"z"}}, }, }}}, }, }}}}}, {"DoubleValue", Unmarshaler{}, `{"dbl":1.2}`, &pb2.KnownTypes{Dbl: &wpb.DoubleValue{Value: 1.2}}}, {"FloatValue", Unmarshaler{}, `{"flt":1.2}`, &pb2.KnownTypes{Flt: &wpb.FloatValue{Value: 1.2}}}, {"Int64Value", Unmarshaler{}, `{"i64":"-3"}`, &pb2.KnownTypes{I64: &wpb.Int64Value{Value: -3}}}, {"UInt64Value", Unmarshaler{}, `{"u64":"3"}`, &pb2.KnownTypes{U64: &wpb.UInt64Value{Value: 3}}}, {"Int32Value", Unmarshaler{}, `{"i32":-4}`, &pb2.KnownTypes{I32: &wpb.Int32Value{Value: -4}}}, {"UInt32Value", Unmarshaler{}, `{"u32":4}`, &pb2.KnownTypes{U32: &wpb.UInt32Value{Value: 4}}}, {"BoolValue", Unmarshaler{}, `{"bool":true}`, &pb2.KnownTypes{Bool: &wpb.BoolValue{Value: true}}}, {"StringValue", Unmarshaler{}, `{"str":"plush"}`, &pb2.KnownTypes{Str: &wpb.StringValue{Value: "plush"}}}, {"StringValue containing escaped character", Unmarshaler{}, `{"str":"a\/b"}`, &pb2.KnownTypes{Str: &wpb.StringValue{Value: "a/b"}}}, {"StructValue containing StringValue's", Unmarshaler{}, `{"escaped": "a\/b", "unicode": "\u00004E16\u0000754C"}`, &stpb.Struct{ Fields: map[string]stpb.Value{ "escaped": {Kind: &stpb.Value_StringValue{"a/b"}}, "unicode": {Kind: &stpb.Value_StringValue{"\u00004E16\u0000754C"}}, }, }}, {"BytesValue", Unmarshaler{}, `{"bytes":"d293"}`, &pb2.KnownTypes{Bytes: &wpb.BytesValue{Value: []byte("wow")}}}, // Ensure that `null` as a value ends up with a nil pointer instead of a [type]Value struct. {"null DoubleValue", Unmarshaler{}, `{"dbl":null}`, &pb2.KnownTypes{Dbl: nil}}, {"null FloatValue", Unmarshaler{}, `{"flt":null}`, &pb2.KnownTypes{Flt: nil}}, {"null Int64Value", Unmarshaler{}, `{"i64":null}`, &pb2.KnownTypes{I64: nil}}, {"null UInt64Value", Unmarshaler{}, `{"u64":null}`, &pb2.KnownTypes{U64: nil}}, {"null Int32Value", Unmarshaler{}, `{"i32":null}`, &pb2.KnownTypes{I32: nil}}, {"null UInt32Value", Unmarshaler{}, `{"u32":null}`, &pb2.KnownTypes{U32: nil}}, {"null BoolValue", Unmarshaler{}, `{"bool":null}`, &pb2.KnownTypes{Bool: nil}}, {"null StringValue", Unmarshaler{}, `{"str":null}`, &pb2.KnownTypes{Str: nil}}, {"null BytesValue", Unmarshaler{}, `{"bytes":null}`, &pb2.KnownTypes{Bytes: nil}}, {"required", Unmarshaler{}, `{"str":"hello"}`, &pb2.MsgWithRequired{Str: proto.String("hello")}}, {"required bytes", Unmarshaler{}, `{"byts": []}`, &pb2.MsgWithRequiredBytes{Byts: []byte{}}}, } func TestUnmarshaling(t testing.T) { for _, tt := range unmarshalingTests { // Make a new instance of the type of our wanted object. p := reflect.New(reflect.TypeOf(tt.pb).Elem()).Interface().(proto.Message) err := tt.unmarshaler.Unmarshal(strings.NewReader(tt.json), p) if err != nil { t.Errorf("unmarshaling %s: %v", tt.desc, err) continue } // For easier diffs, compare text strings of the protos. exp := proto.MarshalTextString(tt.pb) act := proto.MarshalTextString(p) if string(exp) != string(act) { t.Errorf("%s: got [%s] want [%s]", tt.desc, act, exp) } } } func TestUnmarshalNullArray(t testing.T) { var repeats pb2.Repeats if err := UnmarshalString(`{"rBool":null}`, &repeats); err != nil { t.Fatal(err) } if !proto.Equal(&repeats, &pb2.Repeats{}) { t.Errorf("got non-nil fields in [%#v]", repeats) } } func TestUnmarshalNullObject(t testing.T) { var maps pb2.Maps if err := UnmarshalString(`{"mInt64Str":null}`, &maps); err != nil { t.Fatal(err) } if !proto.Equal(&maps, &pb2.Maps{}) { t.Errorf("got non-nil fields in [%#v]", maps) } } func TestUnmarshalNext(t testing.T) { // We only need to check against a few, not all of them. tests := unmarshalingTests[:5] // Create a buffer with many concatenated JSON objects. var b bytes.Buffer for _, tt := range tests { b.WriteString(tt.json) } dec := json.NewDecoder(&b) for _, tt := range tests { // Make a new instance of the type of our wanted object. p := reflect.New(reflect.TypeOf(tt.pb).Elem()).Interface().(proto.Message) err := tt.unmarshaler.UnmarshalNext(dec, p) if err != nil { t.Errorf("%s: %v", tt.desc, err) continue } // For easier diffs, compare text strings of the protos. exp := proto.MarshalTextString(tt.pb) act := proto.MarshalTextString(p) if string(exp) != string(act) { t.Errorf("%s: got [%s] want [%s]", tt.desc, act, exp) } } p := &pb2.Simple{} err := new(Unmarshaler).UnmarshalNext(dec, p) if err != io.EOF { t.Errorf("eof: got %v, want io.EOF", err) } } var unmarshalingShouldError = []struct { desc string in string pb proto.Message }{ {"a value", "666", new(pb2.Simple)}, {"gibberish", "{adskja123;l23=-=", new(pb2.Simple)}, {"unknown field", `{"unknown": "foo"}`, new(pb2.Simple)}, {"unknown enum name", `{"hilarity":"DAVE"}`, new(pb3.Message)}, {"Duration containing invalid character", `{"dur": "3\U0073"}`, &pb2.KnownTypes{}}, {"Timestamp containing invalid character", `{"ts": "2014-05-13T16:53:20\U005a"}`, &pb2.KnownTypes{}}, {"StringValue containing invalid character", `{"str": "\U00004E16\U0000754C"}`, &pb2.KnownTypes{}}, {"StructValue containing invalid character", `{"str": "\U00004E16\U0000754C"}`, &stpb.Struct{}}, {"repeated proto3 enum with non array input", `{"rFunny":"PUNS"}`, &pb3.Message{RFunny: []pb3.Message_Humour{}}}, {"unknown extension field", `{"[ext_unknown]": "value"}`, &pb2.Real{}}, {"extension field for wrong message", `{"[jsonpb_test.name]": "value"}`, &pb2.Complex{}}, } func TestUnmarshalingBadInput(t testing.T) { for _, tt := range unmarshalingShouldError { err := UnmarshalString(tt.in, tt.pb) if err == nil { t.Errorf("expected error while parsing %q", tt.desc) } } } type funcResolver func(turl string) (proto.Message, error) func (fn funcResolver) Resolve(turl string) (proto.Message, error) { return fn(turl) } func TestAnyWithCustomResolver(t testing.T) { var resolvedTypeUrls []string resolver := funcResolver(func(turl string) (proto.Message, error) { resolvedTypeUrls = append(resolvedTypeUrls, turl) return new(pb2.Simple), nil }) msg := &pb2.Simple{ OBytes: []byte{1, 2, 3, 4}, OBool: proto.Bool(true), OString: proto.String("foobar"), OInt64: proto.Int64(1020304), } msgBytes, err := proto.Marshal(msg) if err != nil { t.Errorf("an unexpected error while marshaling message: %v", err) } // make an Any with a type URL that won't resolve w/out custom resolver any := &anypb.Any{ TypeUrl: "https://foobar.com/some.random.MessageKind", Value: msgBytes, } m := Marshaler{AnyResolver: resolver} js, err := m.MarshalToString(any) if err != nil { t.Errorf("an unexpected error while marshaling any to JSON: %v", err) } if len(resolvedTypeUrls) != 1 { t.Errorf("custom resolver was not invoked during marshaling") } else if resolvedTypeUrls[0] != "https://foobar.com/some.random.MessageKind" { t.Errorf("custom resolver was invoked with wrong URL: got %q, wanted %q", resolvedTypeUrls[0], "https://foobar.com/some.random.MessageKind") } wanted := `{"@type":"https://foobar.com/some.random.MessageKind","oBool":true,"oInt64":"1020304","oString":"foobar","oBytes":"AQIDBA=="}` if js != wanted { t.Errorf("marshaling JSON produced incorrect output: got %s, wanted %s", js, wanted) } u := Unmarshaler{AnyResolver: resolver} roundTrip := &anypb.Any{} err = u.Unmarshal(bytes.NewReader([]byte(js)), roundTrip) if err != nil { t.Errorf("an unexpected error while unmarshaling any from JSON: %v", err) } if len(resolvedTypeUrls) != 2 { t.Errorf("custom resolver was not invoked during marshaling") } else if resolvedTypeUrls[1] != "https://foobar.com/some.random.MessageKind" { t.Errorf("custom resolver was invoked with wrong URL: got %q, wanted %q", resolvedTypeUrls[1], "https://foobar.com/some.random.MessageKind") } if !proto.Equal(any, roundTrip) { t.Errorf("message contents not set correctly after unmarshaling JSON: got %s, wanted %s", roundTrip, any) } } func TestUnmarshalJSONPBUnmarshaler(t testing.T) { rawJson := `{ "foo": "bar", "baz": [0, 1, 2, 3] }` var msg dynamicMessage if err := Unmarshal(strings.NewReader(rawJson), &msg); err != nil { t.Errorf("an unexpected error while parsing into JSONPBUnmarshaler: %v", err) } if msg.RawJson != rawJson { t.Errorf("message contents not set correctly after unmarshaling JSON: got %s, wanted %s", msg.RawJson, rawJson) } } func TestUnmarshalNullWithJSONPBUnmarshaler(t testing.T) { rawJson := `{"stringField":null}` var ptrFieldMsg ptrFieldMessage if err := Unmarshal(strings.NewReader(rawJson), &ptrFieldMsg); err != nil { t.Errorf("unmarshal error: %v", err) } want := ptrFieldMessage{StringField: &stringField{IsSet: true, StringValue: "null"}} if !proto.Equal(&ptrFieldMsg, &want) { t.Errorf("unmarshal result StringField: got %v, want %v", ptrFieldMsg, want) } } func TestUnmarshalAnyJSONPBUnmarshaler(t testing.T) { rawJson := `{ "@type": "blah.com/` + dynamicMessageName + `", "foo": "bar", "baz": [0, 1, 2, 3] }` var got anypb.Any if err := Unmarshal(strings.NewReader(rawJson), &got); err != nil { t.Errorf("an unexpected error while parsing into JSONPBUnmarshaler: %v", err) } dm := &dynamicMessage{RawJson: `{"baz":[0,1,2,3],"foo":"bar"}`} var want anypb.Any if b, err := proto.Marshal(dm); err != nil { t.Errorf("an unexpected error while marshaling message: %v", err) } else { want.TypeUrl = "blah.com/" + dynamicMessageName want.Value = b } if !proto.Equal(&got, &want) { t.Errorf("message contents not set correctly after unmarshaling JSON: got %v, wanted %v", &got, &want) } } const ( dynamicMessageName = "github_com.golang.protobuf.jsonpb.dynamicMessage" ) func init() { // we register the custom type below so that we can use it in Any types proto.RegisterType((dynamicMessage)(nil), dynamicMessageName) } type ptrFieldMessage struct { StringField stringField `protobuf:"bytes,1,opt,name=stringField"` } func (m ptrFieldMessage) Reset() { } func (m ptrFieldMessage) String() string { return m.StringField.StringValue } func (m ptrFieldMessage) ProtoMessage() { } func (m ptrFieldMessage) Descriptor() ([]byte, []int) { return testMessageFD, []int{0} } type stringField struct { IsSet bool `protobuf:"varint,1,opt,name=isSet"` StringValue string `protobuf:"bytes,2,opt,name=stringValue"` } func (s stringField) Reset() { } func (s stringField) String() string { return s.StringValue } func (s stringField) ProtoMessage() { } func (s stringField) Descriptor() ([]byte, []int) { return testMessageFD, []int{1} } func (s stringField) UnmarshalJSONPB(jum Unmarshaler, js []byte) error { s.IsSet = true s.StringValue = string(js) return nil } // dynamicMessage implements protobuf.Message but is not a normal generated message type. // It provides implementations of JSONPBMarshaler and JSONPBUnmarshaler for JSON support. type dynamicMessage struct { RawJson string `protobuf:"bytes,1,opt,name=rawJson"` // an unexported nested message is present just to ensure that it // won't result in a panic (see issue #509) Dummy dynamicMessage `protobuf:"bytes,2,opt,name=dummy"` } func (m dynamicMessage) Reset() { m.RawJson = "{}" } func (m dynamicMessage) String() string { return m.RawJson } func (m dynamicMessage) ProtoMessage() { } func (m dynamicMessage) Descriptor() ([]byte, []int) { return testMessageFD, []int{2} } func (m dynamicMessage) MarshalJSONPB(jm Marshaler) ([]byte, error) { return []byte(m.RawJson), nil } func (m dynamicMessage) UnmarshalJSONPB(jum Unmarshaler, js []byte) error { m.RawJson = string(js) return nil } var testMessageFD = func() []byte { fd := new(descpb.FileDescriptorProto) proto.UnmarshalText(` name: "jsonpb.proto" package: "github_com.golang.protobuf.jsonpb" syntax: "proto3" message_type: [{ name: "ptrFieldMessage" field: [ {name:"stringField" number:1 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".github_com.golang.protobuf.jsonpb.stringField"} ] }, { name: "stringField" field: [ {name:"isSet" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL}, {name:"stringValue" number:2 label:LABEL_OPTIONAL type:TYPE_STRING} ] }, { name: "dynamicMessage" field: [ {name:"rawJson" number:1 label:LABEL_OPTIONAL type:TYPE_BYTES}, {name:"dummy" number:2 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".github_com.golang.protobuf.jsonpb.dynamicMessage"} ] }] `, fd) b, _ := proto.Marshal(fd) var buf bytes.Buffer zw := gzip.NewWriter(&buf) zw.Write(b) zw.Close() return buf.Bytes() }() // Test unmarshaling message containing unset required fields should produce error. func TestUnmarshalUnsetRequiredFields(t *testing.T) { tests := []struct { desc string pb proto.Message json string }{ { desc: "direct required field missing", pb: &pb2.MsgWithRequired{}, json: `{}`, }, { desc: "direct required field set to null", pb: &pb2.MsgWithRequired{}, json: `{"str": null}`, }, { desc: "indirect required field missing", pb: &pb2.MsgWithIndirectRequired{}, json: `{"subm": {}}`, }, { desc: "indirect required field set to null", pb: &pb2.MsgWithIndirectRequired{}, json: `{"subm": {"str": null}}`, }, { desc: "direct required bytes field missing", pb: &pb2.MsgWithRequiredBytes{}, json: `{}`, }, { desc: "direct required bytes field set to null", pb: &pb2.MsgWithRequiredBytes{}, json: `{"byts": null}`, }, { desc: "direct required wkt field missing", pb: &pb2.MsgWithRequiredWKT{}, json: `{}`, }, { desc: "direct required wkt field set to null", pb: &pb2.MsgWithRequiredWKT{}, json: `{"str": null}`, }, { desc: "any containing message with required field set to null", pb: &pb2.KnownTypes{}, json: `{"an": {"@type": "example.com/jsonpb.MsgWithRequired", "str": null}}`, }, { desc: "any containing message with missing required field", pb: &pb2.KnownTypes{}, json: `{"an": {"@type": "example.com/jsonpb.MsgWithRequired"}}`, }, { desc: "missing required in map value", pb: &pb2.MsgWithIndirectRequired{}, json: `{"map_field": {"a": {}, "b": {"str": "hi"}}}`, }, { desc: "required in map value set to null", pb: &pb2.MsgWithIndirectRequired{}, json: `{"map_field": {"a": {"str": "hello"}, "b": {"str": null}}}`, }, { desc: "missing required in slice item", pb: &pb2.MsgWithIndirectRequired{}, json: `{"slice_field": [{}, {"str": "hi"}]}`, }, { desc: "required in slice item set to null", pb: &pb2.MsgWithIndirectRequired{}, json: `{"slice_field": [{"str": "hello"}, {"str": null}]}`, }, { desc: "required inside oneof missing", pb: &pb2.MsgWithOneof{}, json: `{"msgWithRequired": {}}`, }, { desc: "required inside oneof set to null", pb: &pb2.MsgWithOneof{}, json: `{"msgWithRequired": {"str": null}}`, }, { desc: "required field in extension missing", pb: &pb2.Real{}, json: `{"[jsonpb.extm]":{}}`, }, { desc: "required field in extension set to null", pb: &pb2.Real{}, json: `{"[jsonpb.extm]":{"str": null}}`, }, } for _, tc := range tests { if err := UnmarshalString(tc.json, tc.pb); err == nil { t.Errorf("%s: expected error while unmarshaling with unset required fields %s", tc.desc, tc.json) } } }	45.22 KB	2025-05-25 12:27

Terminal