func BenchmarkMarshalTextUnbuffered(b *testing.B) { w := ioutil.Discard m := newTestMessage() for i := 0; i < b.N; i++ { proto.MarshalText(w, m) } }
func BenchmarkMarshalTextBuffered(b *testing.B) { buf := new(bytes.Buffer) m := newTestMessage() for i := 0; i < b.N; i++ { buf.Reset() proto.MarshalText(buf, m) } }
func TestMarshalTextCustomMessage(t *testing.T) { buf := new(bytes.Buffer) if err := proto.MarshalText(buf, &textMessage{}); err != nil { t.Fatalf("proto.MarshalText: %v", err) } s := buf.String() if s != "custom" { t.Errorf("Got %q, expected %q", s, "custom") } }
func TestMarshalText(t *testing.T) { buf := new(bytes.Buffer) if err := proto.MarshalText(buf, newTestMessage()); err != nil { t.Fatalf("proto.MarshalText: %v", err) } s := buf.String() if s != text { t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v===\n", s, text) } }
func lookup(domain *db.Domain) { if *table == "station" { stationdb := domain.NewStationDB() s, err := stationdb.Lookup(*id) if err != nil { log.Fatalf("Error looking up station: %s", err.Error()) } proto.MarshalText(os.Stdout, s) } else if *table == "contact" { contactdb := domain.NewContactDB() s, err := contactdb.Lookup(*id) if err != nil { log.Fatalf("Error looking up contact: %s", err.Error()) } proto.MarshalText(os.Stdout, s) } else { log.Fatalf("Unknown table: %s", *table) } }
func BenchmarkMarshalText(b *testing.B) { b.StopTimer() file, _ := os.OpenFile("a.txt", os.O_WRONLY|os.O_CREATE, 0644) defer file.Close() b.StartTimer() for i := 0; i < b.N; i++ { err := proto.MarshalText(file, msg) if checkerr(err) { break } } }
func TestMarshalTextNil(t *testing.T) { want := "<nil>" tests := []proto.Message{nil, (*pb.MyMessage)(nil)} for i, test := range tests { buf := new(bytes.Buffer) if err := proto.MarshalText(buf, test); err != nil { t.Fatal(err) } if got := buf.String(); got != want { t.Errorf("%d: got %q want %q", i, got, want) } } }
func TestMarshalTextFailing(t *testing.T) { // Try lots of different sizes to exercise more error code-paths. for lim := 0; lim < len(text); lim++ { buf := new(limitedWriter) buf.limit = lim err := proto.MarshalText(buf, newTestMessage()) // We expect a certain error, but also some partial results in the buffer. if err != outOfSpace { t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v===\n", err, outOfSpace) } s := buf.b.String() x := text[:buf.limit] if s != x { t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v===\n", s, x) } } }
func TestStringEscaping(t *testing.T) { testCases := []struct { in *pb.Strings out string }{ { // Test data from C++ test (TextFormatTest.StringEscape). // Single divergence: we don't escape apostrophes. &pb.Strings{StringField: proto.String("\"A string with ' characters \n and \r newlines and \t tabs and \001 slashes \\ and multiple spaces")}, "string_field: \"\\\"A string with ' characters \\n and \\r newlines and \\t tabs and \\001 slashes \\\\ and multiple spaces\"\n", }, { // Test data from the same C++ test. &pb.Strings{StringField: proto.String("\350\260\267\346\255\214")}, "string_field: \"\\350\\260\\267\\346\\255\\214\"\n", }, { // Some UTF-8. &pb.Strings{StringField: proto.String("\x00\x01\xff\x81")}, `string_field: "\000\001\377\201"` + "\n", }, } for i, tc := range testCases { var buf bytes.Buffer if err := proto.MarshalText(&buf, tc.in); err != nil { t.Errorf("proto.MarsalText: %v", err) continue } s := buf.String() if s != tc.out { t.Errorf("#%d: Got:\n%s\nExpected:\n%s\n", i, s, tc.out) continue } // Check round-trip. pb := new(pb.Strings) if err := proto.UnmarshalText(s, pb); err != nil { t.Errorf("#%d: UnmarshalText: %v", i, err) continue } if !proto.Equal(pb, tc.in) { t.Errorf("#%d: Round-trip failed:\nstart: %v\n end: %v", i, tc.in, pb) } } }
func main() { log.SetFlags(0) if len(os.Args) != 2 { log.Fatal("usage: mbta file.pb") } pb, err := ioutil.ReadFile(os.Args[1]) if err != nil { log.Fatal(err) } var feed gtfs.FeedMessage if err := proto.Unmarshal(pb, &feed); err != nil { log.Fatal(err) } proto.MarshalText(os.Stdout, &feed) }
func marchalText() { m := &MyMessage{Count: proto.Int32(1234), Name: proto.String("protoName"), Quote: proto.String("protoQuote")} m.Pet = []string{"1", "2", "3"} // MarshalTextString fmt.Println("// MarshalTextString...") mstr := proto.MarshalTextString(m) fmt.Println(mstr) var target MyMessage proto.UnmarshalText(mstr, &target) fmt.Printf("%#v\n", target) fmt.Printf("%s\n", target.String()) fmt.Println("// MarshalTextString...\n") // MarshalText fmt.Println("// MarshalText...") mterr := proto.MarshalText(os.Stdout, m) checkerr(mterr) var target1 MyMessage umterr := proto.UnmarshalText(mstr, &target1) checkerr(umterr) fmt.Printf("%#v\n", target1) fmt.Println(target1.String()) fmt.Println("// MarshalText...\n") // Marshal fmt.Println("// Marshal...") data, _ := proto.Marshal(m) fmt.Println(data) var target2 MyMessage uerr := proto.Unmarshal(data, &target2) checkerr(uerr) fmt.Printf("%#v\n", target2) fmt.Printf("%s\n", target2.String()) fmt.Println("// Marshal...\n") // // MarshalSet // fmt.Println("// MarshalSet...") // var mset proto.MessageSet // merr := mset.Marshal(m) // checkerr(merr) // fmt.Println(mset.Item) // fmt.Println(mset.XXX_unrecognized) // var target3 MyMessage // mset.Unmarshal(&target3) // fmt.Printf("%#v\n", target3) }
func main() { flag.Parse() if len(*makeAnnounce) > 0 { msgBytes, err := ioutil.ReadFile(*makeAnnounce) if err != nil { panic(err) } announce := &pond.Message{ Id: proto.Uint64(0), Time: proto.Int64(time.Now().Unix()), Body: msgBytes, MyNextDh: []byte{}, BodyEncoding: pond.Message_RAW.Enum(), } announceBytes, err := proto.Marshal(announce) if err != nil { panic(err) } os.Stdout.Write(announceBytes) return } if len(*baseDirectory) == 0 { log.Fatalf("Must give --base-directory") return } configPath := filepath.Join(*baseDirectory, configFilename) var identity [32]byte if *initFlag { if err := os.MkdirAll(*baseDirectory, 0700); err != nil { log.Fatalf("Failed to create base directory: %s", err) return } if _, err := io.ReadFull(rand.Reader, identity[:]); err != nil { log.Fatalf("Failed to read random bytes: %s", err) return } if err := ioutil.WriteFile(filepath.Join(*baseDirectory, identityFilename), identity[:], 0600); err != nil { log.Fatalf("Failed to write identity file: %s", err) return } defaultConfig := &protos.Config{ Port: proto.Uint32(uint32(*port)), } configFile, err := os.OpenFile(configPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600) if err != nil { log.Fatalf("Failed to create config file: %s", err) } proto.MarshalText(configFile, defaultConfig) configFile.Close() } identityBytes, err := ioutil.ReadFile(filepath.Join(*baseDirectory, identityFilename)) if err != nil { log.Print("Use --init to setup a new base directory") log.Fatalf("Failed to read identity file: %s", err) return } if len(identityBytes) != 32 { log.Fatalf("Identity file is not 32 bytes long") return } copy(identity[:], identityBytes) config := new(protos.Config) configBytes, err := ioutil.ReadFile(configPath) if err != nil { log.Fatalf("No config file found") } if err := proto.UnmarshalText(string(configBytes), config); err != nil { log.Fatalf("Failed to parse config: %s", err) } ip := net.IPv4(127, 0, 0, 1) // IPv4 loopback interface if config.Address != nil { if ip = net.ParseIP(*config.Address); ip == nil { log.Fatalf("Failed to parse address from config: %s", ip) } } listenAddr := net.TCPAddr{ IP: ip, Port: int(*config.Port), } listener, err := net.ListenTCP("tcp", &listenAddr) if err != nil { log.Fatalf("Failed to listen on port: %s", err) } var identityPublic [32]byte curve25519.ScalarBaseMult(&identityPublic, &identity) identityString := strings.Replace(base32.StdEncoding.EncodeToString(identityPublic[:]), "=", "", -1) log.Printf("Started. Listening on port %d with identity %s", listener.Addr().(*net.TCPAddr).Port, identityString) server := NewServer(*baseDirectory, config.GetAllowRegistration()) if *lifelineFd > -1 { lifeline := os.NewFile(uintptr(*lifelineFd), "lifeline") go func() { var buf [1]byte lifeline.Read(buf[:]) os.Exit(255) }() } for { conn, err := listener.Accept() if err != nil { log.Printf("Error accepting connection: %s", err) continue } go handleConnection(server, conn, &identity) } }
func PrintToString(pb interface{}) string { buf := new(bytes.Buffer) proto.MarshalText(buf, pb) return buf.String() }