func (this *varintWriter) WriteMsg(msg proto.Message) (err error) { var data []byte if m, ok := msg.(marshaler); ok { n, ok := getSize(m) if !ok { data, err = proto.Marshal(msg) if err != nil { return err } } if n >= len(this.buffer) { this.buffer = make([]byte, n) } _, err = m.MarshalTo(this.buffer) if err != nil { return err } data = this.buffer[:n] } else { data, err = proto.Marshal(msg) if err != nil { return err } } length := uint64(len(data)) n := binary.PutUvarint(this.lenBuf, length) _, err = this.w.Write(this.lenBuf[:n]) if err != nil { return err } _, err = this.w.Write(data) return err }
func (this *fullWriter) WriteMsg(msg proto.Message) (err error) { var data []byte if m, ok := msg.(marshaler); ok { n, ok := getSize(m) if !ok { data, err = proto.Marshal(msg) if err != nil { return err } } if n >= len(this.buffer) { this.buffer = make([]byte, n) } _, err = m.MarshalTo(this.buffer) if err != nil { return err } data = this.buffer[:n] } else { data, err = proto.Marshal(msg) if err != nil { return err } } _, err = this.w.Write(data) return err }
func TestRepeatedExtensionsMsgsIssue161(t *testing.T) { r := rand.New(rand.NewSource(time.Now().UnixNano())) rep := 10 nins := make([]*NinOptNative, rep) for i := range nins { nins[i] = NewPopulatedNinOptNative(r, true) } input := &MyExtendable{} if err := proto.SetExtension(input, E_FieldE, nins); err != nil { t.Fatal(err) } data, err := proto.Marshal(input) if err != nil { t.Fatal(err) } output := &MyExtendable{} if err := proto.Unmarshal(data, output); err != nil { t.Fatal(err) } if !input.Equal(output) { t.Fatal("expected equal") } data2, err2 := proto.Marshal(output) if err2 != nil { t.Fatal(err2) } if len(data) != len(data2) { t.Fatal("expected equal length buffers") } }
func TestRepeatedExtensionsFieldsIssue161(t *testing.T) { r := rand.New(rand.NewSource(time.Now().UnixNano())) rep := 10 ints := make([]int64, rep) for i := range ints { ints[i] = r.Int63() } input := &MyExtendable{} if err := proto.SetExtension(input, E_FieldD, ints); err != nil { t.Fatal(err) } data, err := proto.Marshal(input) if err != nil { t.Fatal(err) } output := &MyExtendable{} if err := proto.Unmarshal(data, output); err != nil { t.Fatal(err) } if !input.Equal(output) { t.Fatal("expected equal") } data2, err2 := proto.Marshal(output) if err2 != nil { t.Fatal(err2) } if len(data) != len(data2) { t.Fatal("expected equal length buffers") } }
func TestOldUnoM(t *testing.T) { popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) older := NewPopulatedOldUnoM(popr, true) // need optional field to be always initialized, to check it's lost in this test older.Field1 = proto.String(randStringUnrecognized(popr)) data1, err := proto.Marshal(older) if err != nil { panic(err) } newer := &UnoM{} if err = proto.Unmarshal(data1, newer); err != nil { panic(err) } data2, err := proto.Marshal(newer) if err != nil { panic(err) } older2 := &OldUnoM{} if err := proto.Unmarshal(data2, older2); err != nil { panic(err) } // check that Field1 is lost if older2.Field1 != nil { t.Fatalf("field must be lost, but it's not, older: %#v, older2: %#v", older, older2) } // now restore Field1 and messages should be equal now older2.Field1 = older.Field1 if err := older.VerboseEqual(older2); err != nil { t.Fatalf("%#v !VerboseProto %#v, since %v", older, older2, err) } }
func (this *uint32Writer) WriteMsg(msg proto.Message) (err error) { var data []byte if m, ok := msg.(marshaler); ok { n, ok := getSize(m) if !ok { data, err = proto.Marshal(msg) if err != nil { return err } } if n >= len(this.buffer) { this.buffer = make([]byte, n) } _, err = m.MarshalTo(this.buffer) if err != nil { return err } data = this.buffer[:n] } else { data, err = proto.Marshal(msg) if err != nil { return err } } length := uint32(len(data)) if err = binary.Write(this.w, this.byteOrder, &length); err != nil { return err } _, err = this.w.Write(data) return err }
func TestCastawayProto(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) p := NewPopulatedCastaway(popr, false) data, err := github_com_maditya_protobuf_proto.Marshal(p) if err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } msg := &Castaway{} if err := github_com_maditya_protobuf_proto.Unmarshal(data, msg); err != nil { t.Fatalf("seed = %d, err = %v", seed, err) } littlefuzz := make([]byte, len(data)) copy(littlefuzz, data) for i := range data { data[i] = byte(popr.Intn(256)) } if err := p.VerboseEqual(msg); err != nil { t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) } if !p.Equal(msg) { t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) } if len(littlefuzz) > 0 { fuzzamount := 100 for i := 0; i < fuzzamount; i++ { littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) littlefuzz = append(littlefuzz, byte(popr.Intn(256))) } // shouldn't panic _ = github_com_maditya_protobuf_proto.Unmarshal(littlefuzz, msg) } }
//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 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") } }
func TestRoundTripProto3(t *testing.T) { m := &pb.Message{ Name: "David", // (2 | 1<<3): 0x0a 0x05 "David" Hilarity: pb.Message_PUNS, // (0 | 2<<3): 0x10 0x01 HeightInCm: 178, // (0 | 3<<3): 0x18 0xb2 0x01 Data: []byte("roboto"), // (2 | 4<<3): 0x20 0x06 "roboto" ResultCount: 47, // (0 | 7<<3): 0x38 0x2f TrueScotsman: true, // (0 | 8<<3): 0x40 0x01 Score: 8.1, // (5 | 9<<3): 0x4d <8.1> Key: []uint64{1, 0xdeadbeef}, Nested: &pb.Nested{ Bunny: "Monty", }, } t.Logf(" m: %v", m) b, err := proto.Marshal(m) if err != nil { t.Fatalf("proto.Marshal: %v", err) } t.Logf(" b: %q", b) m2 := new(pb.Message) if err := proto.Unmarshal(b, m2); err != nil { t.Fatalf("proto.Unmarshal: %v", err) } t.Logf("m2: %v", m2) if !proto.Equal(m, m2) { t.Errorf("proto.Equal returned false:\n m: %v\nm2: %v", m, m2) } }
func testSize(m interface { proto.Message Size() int }, desc string, expected int) ([]byte, error) { data, err := proto.Marshal(m) if err != nil { return nil, err } protoSize := proto.Size(m) mSize := m.Size() lenData := len(data) if protoSize != mSize || protoSize != lenData || mSize != lenData { return nil, fmt.Errorf("%s proto.Size(m){%d} != m.Size(){%d} != len(data){%d}", desc, protoSize, mSize, lenData) } if got := protoSize; got != expected { return nil, fmt.Errorf("%s proto.Size(m) got %d expected %d", desc, got, expected) } if got := mSize; got != expected { return nil, fmt.Errorf("%s m.Size() got %d expected %d", desc, got, expected) } if got := lenData; got != expected { return nil, fmt.Errorf("%s len(data) got %d expected %d", desc, got, expected) } return data, nil }
func TestUnmarshalPartiallyPopulatedOptionalFieldsFails(t *testing.T) { // Fill in all fields, then randomly remove one. dataOut := &test.NinOptNative{ Field1: proto.Float64(0), Field2: proto.Float32(0), Field3: proto.Int32(0), Field4: proto.Int64(0), Field5: proto.Uint32(0), Field6: proto.Uint64(0), Field7: proto.Int32(0), Field8: proto.Int64(0), Field9: proto.Uint32(0), Field10: proto.Int32(0), Field11: proto.Uint64(0), Field12: proto.Int64(0), Field13: proto.Bool(false), Field14: proto.String("0"), Field15: []byte("0"), } r := rand.New(rand.NewSource(time.Now().UnixNano())) fieldName := "Field" + strconv.Itoa(r.Intn(15)+1) field := reflect.ValueOf(dataOut).Elem().FieldByName(fieldName) fieldType := field.Type() field.Set(reflect.Zero(fieldType)) encodedMessage, err := proto.Marshal(dataOut) if err != nil { t.Fatalf("Unexpected error when marshalling dataOut: %v", err) } dataIn := NidOptNative{} err = proto.Unmarshal(encodedMessage, &dataIn) if err.Error() != `proto: required field "`+fieldName+`" not set` { t.Fatalf(`err.Error() != "proto: required field "`+fieldName+`" not set"; was "%s" instead`, err.Error()) } }
// MarshalAny takes the protocol buffer and encodes it into google.protobuf.Any. func MarshalAny(pb proto.Message) (*Any, error) { value, err := proto.Marshal(pb) if err != nil { return nil, err } return &Any{TypeUrl: googleApis + proto.MessageName(pb), Value: value}, nil }
func TestZeroLengthOptionalBytes(t *testing.T) { roundtrip := func(f *Foo) *Foo { data, err := proto.Marshal(f) if err != nil { panic(err) } newF := &Foo{} err = proto.Unmarshal(data, newF) if err != nil { panic(err) } return newF } f := &Foo{} roundtrippedF := roundtrip(f) if roundtrippedF.Bar != nil { t.Fatalf("should be nil") } f.Bar = []byte{} roundtrippedF = roundtrip(f) if roundtrippedF.Bar == nil { t.Fatalf("should not be nil") } if len(roundtrippedF.Bar) != 0 { t.Fatalf("should be empty") } }
func (this *codec) Marshal(v interface{}) ([]byte, error) { if m, ok := v.(marshaler); ok { n, ok := getSize(v) if !ok { return proto.Marshal(v.(proto.Message)) } if n > len(this.buf) { this.buf = make([]byte, n) } _, err := m.MarshalTo(this.buf) if err != nil { return nil, err } return this.buf[:n], nil } return proto.Marshal(v.(proto.Message)) }
func TestIssue42Order(t *testing.T) { unordered := NewPopulatedUnorderedFields(math_rand.New(math_rand.NewSource(time.Now().UnixNano())), false) udata, err := proto.Marshal(unordered) if err != nil { t.Fatal(err) } ordered := &OrderedFields{} if err = proto.Unmarshal(udata, ordered); err != nil { t.Fatal(err) } data, err := proto.Marshal(ordered) if err != nil { t.Fatal(err) } if !bytes.Equal(udata, data) { t.Fatalf("expected data to be marshaled in the same order, please sort fields before marshaling") } }
func newTestMessage() *pb.MyMessage { msg := &pb.MyMessage{ Count: proto.Int32(42), Name: proto.String("Dave"), Quote: proto.String(`"I didn't want to go."`), Pet: []string{"bunny", "kitty", "horsey"}, Inner: &pb.InnerMessage{ Host: proto.String("footrest.syd"), Port: proto.Int32(7001), Connected: proto.Bool(true), }, Others: []*pb.OtherMessage{ { Key: proto.Int64(0xdeadbeef), Value: []byte{1, 65, 7, 12}, }, { Weight: proto.Float32(6.022), Inner: &pb.InnerMessage{ Host: proto.String("lesha.mtv"), Port: proto.Int32(8002), }, }, }, Bikeshed: pb.MyMessage_BLUE.Enum(), Somegroup: &pb.MyMessage_SomeGroup{ GroupField: proto.Int32(8), }, // One normally wouldn't do this. // This is an undeclared tag 13, as a varint (wire type 0) with value 4. XXX_unrecognized: []byte{13<<3 | 0, 4}, } ext := &pb.Ext{ Data: proto.String("Big gobs for big rats"), } if err := proto.SetExtension(msg, pb.E_Ext_More, ext); err != nil { panic(err) } greetings := []string{"adg", "easy", "cow"} if err := proto.SetExtension(msg, pb.E_Greeting, greetings); err != nil { panic(err) } // Add an unknown extension. We marshal a pb.Ext, and fake the ID. b, err := proto.Marshal(&pb.Ext{Data: proto.String("3G skiing")}) if err != nil { panic(err) } b = append(proto.EncodeVarint(201<<3|proto.WireBytes), b...) proto.SetRawExtension(msg, 201, b) // Extensions can be plain fields, too, so let's test that. b = append(proto.EncodeVarint(202<<3|proto.WireVarint), 19) proto.SetRawExtension(msg, 202, b) return msg }
func TestOldNewOldNew(t *testing.T) { popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) older := NewPopulatedOldWithGroup(popr, true) data1, err := proto.Marshal(older) if err != nil { panic(err) } newer := &NewNoGroup{} if err = proto.Unmarshal(data1, newer); err != nil { panic(err) } data2, err := proto.Marshal(newer) if err != nil { panic(err) } bluer := &OldWithGroup{} if err = proto.Unmarshal(data2, bluer); err != nil { panic(err) } if err = older.VerboseEqual(bluer); err != nil { t.Fatalf("%#v !VerboseProto %#v, since %v", older, bluer, err) } data3, err := proto.Marshal(bluer) if err != nil { panic(err) } purple := &NewNoGroup{} if err = proto.Unmarshal(data3, purple); err != nil { panic(err) } data4, err := proto.Marshal(purple) if err != nil { panic(err) } magenta := &OldWithGroup{} if err := proto.Unmarshal(data4, magenta); err != nil { panic(err) } if err := older.VerboseEqual(magenta); err != nil { t.Fatalf("%#v !VerboseProto %#v, since %v", older, magenta, err) } }
func Write(resp *plugin.CodeGeneratorResponse) { g := generator.New() // Send back the results. data, err := proto.Marshal(resp) if err != nil { g.Error(err, "failed to marshal output proto") } _, err = os.Stdout.Write(data) if err != nil { g.Error(err, "failed to write output proto") } }
//http://code.google.com/p/goprotobuf/issues/detail?id=39 func TestBugUint32VarintSize(t *testing.T) { temp := uint32(math.MaxUint32) n := &NinOptNative{} n.Field5 = &temp data, err := proto.Marshal(n) if err != nil { panic(err) } if len(data) != 6 { t.Fatalf("data should be length 6, but its %#v", data) } }
func TestMarshalToSucceedsWhenRequiredFieldIsPresent(t *testing.T) { data := RequiredExample{ TheRequiredString: proto.String("present"), } buf, err := proto.Marshal(&data) if err != nil { t.Fatalf("err != nil; was %v instead", err) } if len(buf) == 0 { t.Fatalf(`len(buf) == 0; expected nonzero`) } }
func TestUnmarshalPopulatedOptionalFieldsAsRequiredSucceeds(t *testing.T) { r := rand.New(rand.NewSource(time.Now().UnixNano())) dataOut := test.NewPopulatedNidOptNative(r, true) encodedMessage, err := proto.Marshal(dataOut) if err != nil { t.Fatalf("Unexpected error when marshalling dataOut: %v", err) } dataIn := NidOptNative{} err = proto.Unmarshal(encodedMessage, &dataIn) if err != nil { t.Fatalf("err != nil; was %v instead", err) } }
func TestMarshalToErrorsWhenRequiredFieldIsNotPresent(t *testing.T) { data := RequiredExample{} buf, err := proto.Marshal(&data) if err == nil { t.Fatalf("err == nil; was %v instead", err) } if err.Error() != `proto: required field "theRequiredString" not set` { t.Fatalf(`err.Error() != "proto: required field "theRequiredString" not set"; was "%s" instead`, err.Error()) } if len(buf) != 0 { t.Fatalf(`len(buf) != 0; was %d instead`, len(buf)) } }
func TestBugZeroLengthSliceSize(t *testing.T) { n := &NinRepPackedNative{ Field8: []int64{}, } size := n.Size() data, err := proto.Marshal(n) if err != nil { panic(err) } if len(data) != size { t.Fatalf("expected %v, but got %v", len(data), size) } }
func TestNewOld(t *testing.T) { popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) newer := NewPopulatedNewNoGroup(popr, true) data1, err := proto.Marshal(newer) if err != nil { panic(err) } older := &OldWithGroup{} if err = proto.Unmarshal(data1, older); err != nil { panic(err) } data2, err := proto.Marshal(older) if err != nil { panic(err) } bluer := &NewNoGroup{} if err := proto.Unmarshal(data2, bluer); err != nil { panic(err) } if err := newer.VerboseEqual(bluer); err != nil { t.Fatalf("%#v !VerboseProto %#v, since %v", newer, bluer, err) } }
func TestUnmarshalSucceedsWhenRequiredIsNotPresent(t *testing.T) { dataOut := RequiredExample{ TheRequiredString: proto.String("present"), } encodedMessage, err := proto.Marshal(&dataOut) if err != nil { t.Fatalf("Unexpected error when marshalling dataOut: %v", err) } dataIn := RequiredExample{} err = proto.Unmarshal(encodedMessage, &dataIn) if err != nil { t.Fatalf("err != nil; was %v instead", err) } }
func TestCustomTypeMarshalUnmarshal(t *testing.T) { m1 := &Uint128Pair{} if b, err := proto.Marshal(m1); err != nil { t.Fatal(err) } else { m2 := &Uint128Pair{} if err := proto.Unmarshal(b, m2); err != nil { t.Fatal(err) } if !reflect.DeepEqual(m1, m2) { t.Errorf("expected %+v, got %+v", m1, m2) } } }
func TestWilsonVerboseEqual(t *testing.T) { popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) p := NewPopulatedWilson(popr, false) data, err := github_com_maditya_protobuf_proto.Marshal(p) if err != nil { panic(err) } msg := &Wilson{} if err := github_com_maditya_protobuf_proto.Unmarshal(data, msg); err != nil { panic(err) } if err := p.VerboseEqual(msg); err != nil { t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) } }
func TestFullCircleRepProtoToStd(t *testing.T) { seed := time.Now().UnixNano() popr := math_rand.New(math_rand.NewSource(seed)) protoMsg := NewPopulatedRepProtoTypes(popr, true) protoData, err := proto.Marshal(protoMsg) if err != nil { t.Fatal(err) } stdMsg := &RepStdTypes{} if err2 := proto.Unmarshal(protoData, stdMsg); err2 != nil { t.Fatal(err) } stdData, err := proto.Marshal(stdMsg) if err != nil { t.Fatal(err) } protoMsgOut := &RepProtoTypes{} if err3 := proto.Unmarshal(stdData, protoMsgOut); err3 != nil { t.Fatal(err) } if !protoMsg.Equal(protoMsgOut) { t.Fatalf("want %#v got %#v", protoMsg, protoMsgOut) } }
func TestMarshalFailsWithoutAllFieldsSet(t *testing.T) { r := rand.New(rand.NewSource(time.Now().UnixNano())) dataOut := NewPopulatedNinOptNative(r, true) fieldName := "Field" + strconv.Itoa(r.Intn(15)+1) field := reflect.ValueOf(dataOut).Elem().FieldByName(fieldName) fieldType := field.Type() field.Set(reflect.Zero(fieldType)) encodedMessage, err := proto.Marshal(dataOut) if err.Error() != `proto: required field "`+fieldName+`" not set` { t.Fatalf(`err.Error() != "proto: required field "`+fieldName+`" not set"; was "%s" instead`, err.Error()) } if len(encodedMessage) > 0 { t.Fatalf("Got some bytes from marshal, expected none.") } }