func TestNilExtension(t *testing.T) { msg := &pb.MyMessage{ Count: proto.Int32(1), } if err := proto.SetExtension(msg, pb.E_Ext_Text, proto.String("hello")); err != nil { t.Fatal(err) } if err := proto.SetExtension(msg, pb.E_Ext_More, (*pb.Ext)(nil)); err == nil { t.Error("expected SetExtension to fail due to a nil extension") } else if want := "proto: SetExtension called with nil value of type *testdata.Ext"; err.Error() != want { t.Errorf("expected error %v, got %v", want, err) } // Note: if the behavior of Marshal is ever changed to ignore nil extensions, update // this test to verify that E_Ext_Text is properly propagated through marshal->unmarshal. }
func TestExtend(t *testing.T) { fp, err := fieldpath.NewFloat64Path("test", "MyExtendable", test.ThetestDescription(), "FieldA") if err != nil { panic(err) } m := &test.MyExtendable{} err = proto.SetExtension(m, test.E_FieldA, proto.Float64(10.0)) if err != nil { panic(err) } buf, err := proto.Marshal(m) if err != nil { panic(err) } var unmarshalled float64 f := FuncHandler{ Float64Func: func(v float64) { t.Logf("unmarshalled %v", v) unmarshalled = v }, } unmarshaler := fieldpath.NewFloat64Unmarshaler(fp, f) err = unmarshaler.Unmarshal(buf) if err != nil { panic(err) } if unmarshalled != float64(10.0) { panic(fmt.Errorf("wtf %v", unmarshalled)) } }
func TestNoMergeExtensionMerge(t *testing.T) { r := rand.New(rand.NewSource(time.Now().UnixNano())) bigm := test.NewPopulatedMyExtendable(r, true) m := test.NewPopulatedNinOptNative(r, true) err := proto.SetExtension(bigm, test.E_FieldB, m) if err != nil { panic(err) } data, err := proto.Marshal(bigm) if err != nil { panic(err) } key := uint32(101)<<3 | uint32(2) data2 := make([]byte, 10) n := binary.PutUvarint(data2, uint64(key)) data2 = data2[:n] data = append(data, data2...) data4, err := proto.Marshal(test.NewPopulatedNinOptNative(r, true)) if err != nil { panic(err) } data3 := make([]byte, 10) n = binary.PutUvarint(data3, uint64(len(data4))) data3 = data3[:n] data = append(data, data3...) data = append(data, data4...) err = fieldpath.NoMerge(data, test.ThetestDescription(), "test", "MyExtendable") if err == nil || !strings.Contains(err.Error(), "requires merging") { t.Fatalf("should require merging") } }
func TestGetExtensionStability(t *testing.T) { check := func(m *pb.MyMessage) bool { ext1, err := proto.GetExtension(m, pb.E_Ext_More) if err != nil { t.Fatalf("GetExtension() failed: %s", err) } ext2, err := proto.GetExtension(m, pb.E_Ext_More) if err != nil { t.Fatalf("GetExtension() failed: %s", err) } return ext1 == ext2 } msg := &pb.MyMessage{Count: proto.Int32(4)} ext0 := &pb.Ext{} if err := proto.SetExtension(msg, pb.E_Ext_More, ext0); err != nil { t.Fatalf("Could not set ext1: %s", ext0) } if !check(msg) { t.Errorf("GetExtension() not stable before marshaling") } bb, err := proto.Marshal(msg) if err != nil { t.Fatalf("Marshal() failed: %s", err) } msg1 := &pb.MyMessage{} err = proto.Unmarshal(bb, msg1) if err != nil { t.Fatalf("Unmarshal() failed: %s", err) } if !check(msg1) { t.Errorf("GetExtension() not stable after unmarshaling") } }
//See another version of this test in proto/extensions_test.go func TestGetExtensionStability(t *testing.T) { check := func(m *NoExtensionsMap) bool { ext1, err := proto.GetExtension(m, E_FieldB1) if err != nil { t.Fatalf("GetExtension() failed: %s", err) } ext2, err := proto.GetExtension(m, E_FieldB1) if err != nil { t.Fatalf("GetExtension() failed: %s", err) } return ext1.(*NinOptNative).Equal(ext2) } msg := &NoExtensionsMap{Field1: proto.Int64(2)} ext0 := &NinOptNative{Field1: proto.Float64(1)} if err := proto.SetExtension(msg, E_FieldB1, ext0); err != nil { t.Fatalf("Could not set ext1: %s", ext0) } if !check(msg) { t.Errorf("GetExtension() not stable before marshaling") } bb, err := proto.Marshal(msg) if err != nil { t.Fatalf("Marshal() failed: %s", err) } msg1 := &NoExtensionsMap{} err = proto.Unmarshal(bb, msg1) if err != nil { t.Fatalf("Unmarshal() failed: %s", err) } if !check(msg1) { t.Errorf("GetExtension() not stable after unmarshaling") } }
func init() { ext := &pb.Ext{ Data: proto.String("extension"), } if err := proto.SetExtension(cloneTestMessage, pb.E_Ext_More, ext); err != nil { panic("SetExtension: " + err.Error()) } }
func TestExtensionsNoExtensionsMapSetExtension(t *testing.T) { m := NewPopulatedNoExtensionsMap(extr, false) err := proto.SetExtension(m, E_FieldA1, &fieldA) if err != nil { panic(err) } check(t, m, fieldA, E_FieldA1) }
func TestExtensionsMyExtendable(t *testing.T) { m := NewPopulatedMyExtendable(extr, false) err := proto.SetExtension(m, E_FieldA, &fieldA) if err != nil { panic(err) } check(t, m, fieldA, E_FieldA) proto.SetRawExtension(m, 100, fieldABytes) check(t, m, fieldA, E_FieldA) }
func TestExtensionsRoundTrip(t *testing.T) { msg := &pb.MyMessage{} ext1 := &pb.Ext{ Data: proto.String("hi"), } ext2 := &pb.Ext{ Data: proto.String("there"), } exists := proto.HasExtension(msg, pb.E_Ext_More) if exists { t.Error("Extension More present unexpectedly") } if err := proto.SetExtension(msg, pb.E_Ext_More, ext1); err != nil { t.Error(err) } if err := proto.SetExtension(msg, pb.E_Ext_More, ext2); err != nil { t.Error(err) } e, err := proto.GetExtension(msg, pb.E_Ext_More) if err != nil { t.Error(err) } x, ok := e.(*pb.Ext) if !ok { t.Errorf("e has type %T, expected testdata.Ext", e) } else if *x.Data != "there" { t.Errorf("SetExtension failed to overwrite, got %+v, not 'there'", x) } proto.ClearExtension(msg, pb.E_Ext_More) if _, err = proto.GetExtension(msg, pb.E_Ext_More); err != proto.ErrMissingExtension { t.Errorf("got %v, expected ErrMissingExtension", e) } if _, err := proto.GetExtension(msg, pb.E_X215); err == nil { t.Error("expected bad extension error, got nil") } if err := proto.SetExtension(msg, pb.E_X215, 12); err == nil { t.Error("expected extension err") } if err := proto.SetExtension(msg, pb.E_Ext_More, 12); err == nil { t.Error("expected some sort of type mismatch error, got nil") } }
func SetBoolMessageOption(extension *proto.ExtensionDesc, value bool) func(msg *descriptor.DescriptorProto) { return func(msg *descriptor.DescriptorProto) { if MessageHasBoolExtension(msg, extension) { return } if msg.Options == nil { msg.Options = &descriptor.MessageOptions{} } if err := proto.SetExtension(msg.Options, extension, &value); err != nil { panic(err) } } }
func SetBoolFieldOption(extension *proto.ExtensionDesc, value bool) func(field *descriptor.FieldDescriptorProto) { return func(field *descriptor.FieldDescriptorProto) { if FieldHasBoolExtension(field, extension) { return } if field.Options == nil { field.Options = &descriptor.FieldOptions{} } if err := proto.SetExtension(field.Options, extension, &value); err != nil { panic(err) } } }
func SetBoolEnumOption(extension *proto.ExtensionDesc, value bool) func(enum *descriptor.EnumDescriptorProto) { return func(enum *descriptor.EnumDescriptorProto) { if EnumHasBoolExtension(enum, extension) { return } if enum.Options == nil { enum.Options = &descriptor.EnumOptions{} } if err := proto.SetExtension(enum.Options, extension, &value); err != nil { panic(err) } } }
func TestNoMergeExtensionNoMerge(t *testing.T) { r := rand.New(rand.NewSource(time.Now().UnixNano())) bigm := test.NewPopulatedMyExtendable(r, true) m := test.NewPopulatedNinOptNative(r, true) err := proto.SetExtension(bigm, test.E_FieldB, m) if err != nil { panic(err) } data, err := proto.Marshal(bigm) if err != nil { panic(err) } err = fieldpath.NoMerge(data, test.ThetestDescription(), "test", "MyExtendable") if err != nil { panic(err) } }
func TestGetExtensionsWithMissingExtensions(t *testing.T) { msg := &pb.MyMessage{} ext1 := &pb.Ext{} if err := proto.SetExtension(msg, pb.E_Ext_More, ext1); err != nil { t.Fatalf("Could not set ext1: %s", ext1) } exts, err := proto.GetExtensions(msg, []*proto.ExtensionDesc{ pb.E_Ext_More, pb.E_Ext_Text, }) if err != nil { t.Fatalf("GetExtensions() failed: %s", err) } if exts[0] != ext1 { t.Errorf("ext1 not in returned extensions: %T %v", exts[0], exts[0]) } if exts[1] != nil { t.Errorf("ext2 in returned extensions: %T %v", exts[1], exts[1]) } }