func TestProto3SetDefaults(t *testing.T) {
in := &pb.Message{
Terrain: map[string]*pb.Nested{
"meadow": new(pb.Nested),
},
Proto2Field: new(tpb.SubDefaults),
Proto2Value: map[string]*tpb.SubDefaults{
"badlands": new(tpb.SubDefaults),
},
}
got := proto.Clone(in).(*pb.Message)
proto.SetDefaults(got)
// There are no defaults in proto3. Everything should be the zero value, but
// we need to remember to set defaults for nested proto2 messages.
want := &pb.Message{
Terrain: map[string]*pb.Nested{
"meadow": new(pb.Nested),
},
Proto2Field: &tpb.SubDefaults{N: proto.Int64(7)},
Proto2Value: map[string]*tpb.SubDefaults{
"badlands": {N: proto.Int64(7)},
},
}
if !proto.Equal(got, want) {
t.Errorf("with in = %v\nproto.SetDefaults(in) =>\ngot %v\nwant %v", in, got, want)
}
}
func ExampleCompile() {
a := &test.NinOptNative{
Field4: proto.Int64(1234),
Field7: proto.Int32(123),
}
fp1, err := fieldpath.NewInt64Path("test", "NinOptNative", test.ThetestDescription(), "Field4")
if err != nil {
panic(err)
}
fp2, err := fieldpath.NewSint32Path("test", "NinOptNative", test.ThetestDescription(), "Field7")
if err != nil {
panic(err)
}
buf, err := proto.Marshal(a)
if err != nil {
panic(err)
}
u1 := fieldpath.NewInt64Unmarshaler(fp1, &handler64{})
u2 := fieldpath.NewSint32Unmarshaler(fp2, &handler32{})
c := fieldpath.Compile(u1, u2)
err = c.Unmarshal(buf)
if err != nil {
panic(err)
}
// Output:
// 1234
// 123
}
//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 ExampleInt64SinglePath() {
a := &test.NinOptNative{
Field4: proto.Int64(1234),
}
fp, err := fieldpath.NewInt64SinglePath("test", "NinOptNative", test.ThetestDescription(), "Field4")
if err != nil {
panic(err)
}
buf, err := proto.Marshal(a)
if err != nil {
panic(err)
}
unmarshalled, err := fp.Unmarshal(buf)
if err != nil {
panic(err)
}
fmt.Printf("%v\n", *unmarshalled)
// Output:
// 1234
}
func ExampleUnmarshaler() {
a := &test.NinOptNative{
Field4: proto.Int64(1234),
}
fp, err := fieldpath.NewInt64Path("test", "NinOptNative", test.ThetestDescription(), "Field4")
if err != nil {
panic(err)
}
buf, err := proto.Marshal(a)
if err != nil {
panic(err)
}
h := &handler{}
u := fieldpath.NewInt64Unmarshaler(fp, h)
err = u.Unmarshal(buf)
if err != nil {
panic(err)
}
// Output:
// 1234
}
func TestUnmarshalMerge(t *testing.T) {
popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano()))
p := NewPopulatedBig(popr, true)
if p.GetSub() == nil {
p.Sub = &Sub{SubNumber: proto.Int64(12345)}
}
data, err := proto.Marshal(p)
if err != nil {
panic(err)
}
s := &Sub{}
b := &Big{
Sub: s,
}
err = proto.UnmarshalMerge(data, b)
if err != nil {
panic(err)
}
if s.GetSubNumber() != p.GetSub().GetSubNumber() {
t.Fatalf("should have unmarshaled subnumber into sub")
}
}
Pet: []string{"horsey"},
Others: []*pb.OtherMessage{
{
Value: []byte("some bytes"),
},
},
},
dst: &pb.MyMessage{
Inner: &pb.InnerMessage{
Host: proto.String("niles"),
Port: proto.Int32(9099),
},
Pet: []string{"bunny", "kitty"},
Others: []*pb.OtherMessage{
{
Key: proto.Int64(31415926535),
},
{
// Explicitly test a src=nil field
Inner: nil,
},
},
},
want: &pb.MyMessage{
Inner: &pb.InnerMessage{
Host: proto.String("hey"),
Connected: proto.Bool(true),
Port: proto.Int32(9099),
},
Pet: []string{"bunny", "kitty", "horsey"},
Others: []*pb.OtherMessage{
func TestInt32Int64Compatibility(t *testing.T) {
//test nullable int32 and int64
data1, err := testSize(&NinOptNative{
Field3: proto.Int32(-1),
}, "nullable", 11)
if err != nil {
t.Error(err)
}
//change marshaled data1 to unmarshal into 4th field which is an int64
data1[0] = uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/))
u1 := &NinOptNative{}
err = proto.Unmarshal(data1, u1)
if err != nil {
t.Error(err)
}
if !u1.Equal(&NinOptNative{
Field4: proto.Int64(-1),
}) {
t.Error("nullable unmarshaled int32 is not the same int64")
}
//test non-nullable int32 and int64
data2, err := testSize(&NidOptNative{
Field3: -1,
}, "non nullable", 67)
if err != nil {
t.Error(err)
}
//change marshaled data2 to unmarshal into 4th field which is an int64
field3 := uint8(uint32(3 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/))
field4 := uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/))
for i, c := range data2 {
if c == field4 {
data2[i] = field3
} else if c == field3 {
data2[i] = field4
}
}
u2 := &NidOptNative{}
err = proto.Unmarshal(data2, u2)
if err != nil {
t.Error(err)
}
if !u2.Equal(&NidOptNative{
Field4: -1,
}) {
t.Error("non nullable unmarshaled int32 is not the same int64")
}
//test repeated int32 and int64
if _, err := testSize(&NinRepNative{
Field3: []int32{-1},
}, "repeated", 11); err != nil {
t.Error(err)
}
//test packed repeated int32 and int64
m4 := &NinRepPackedNative{
Field3: []int32{-1},
}
data4, err := testSize(m4, "packed", 12)
if err != nil {
t.Error(err)
}
u4 := &NinRepPackedNative{}
err = proto.Unmarshal(data4, u4)
if err != nil {
t.Error(err)
}
if err := u4.VerboseEqual(m4); err != nil {
t.Fatalf("%#v", u4)
}
t.Logf("tested all")
}