code review 5574053: encoding/xml: bring API closer to other packages

src/pkg/encoding/xml/marshal_test.go

 // Copyright 2011 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 xml
 
 import (
-        "bytes"
         "reflect"
         "strconv"
         "strings"
         "testing"
 )
 
 type DriveType int
 
 const (
         HyperDrive DriveType = iota
@@ skipping 593 matching lines @@
                 Value:         &IgnoreTest{},
                 UnmarshalOnly: true,
         },
 }
 
 func TestMarshal(t *testing.T) {
         for idx, test := range marshalTests {
                 if test.UnmarshalOnly {
                         continue
                 }
-                buf := bytes.NewBuffer(nil)
-                err := Marshal(buf, test.Value)
+                data, err := Marshal(test.Value)
                 if err != nil {
                         t.Errorf("#%d: Error: %s", idx, err)
                         continue
                 }
-                if got, want := buf.String(), test.ExpectXML; got != want {
+                if got, want := string(data), test.ExpectXML; got != want {
                         if strings.Contains(want, "\n") {
                                 t.Errorf("#%d: marshal(%#v):\nHAVE:\n%s\nWANT:\n%s", idx, test.Value, got, want)
                         } else {
                                 t.Errorf("#%d: marshal(%#v):\nhave %#q\nwant %#q", idx, test.Value, got, want)
                         }
                 }
         }
 }
 
 var marshalErrorTests = []struct {
@@ skipping 20 matching lines @@
                 Kind:  reflect.Map,
         },
         {
                 Value: &Domain{Comment: []byte("f--bar")},
                 Err:   `xml: comments must not contain "--"`,
         },
 }
 
 func TestMarshalErrors(t *testing.T) {
         for idx, test := range marshalErrorTests {
-                buf := bytes.NewBuffer(nil)
-                err := Marshal(buf, test.Value)
+                _, err := Marshal(test.Value)
                 if err == nil || err.Error() != test.Err {
                         t.Errorf("#%d: marshal(%#v) = [error] %v, want %v", idx, test.Value, err, test.Err)
                 }
                 if test.Kind != reflect.Invalid {
                         if kind := err.(*UnsupportedTypeError).Type.Kind(); kind != test.Kind {
                                 t.Errorf("#%d: marshal(%#v) = [error kind] %s, want %s", idx, test.Value, kind, test.Kind)
                         }
                 }
         }
 }
 
 // Do invertibility testing on the various structures that we test
 func TestUnmarshal(t *testing.T) {
         for i, test := range marshalTests {
                 if test.MarshalOnly {
                         continue
                 }
                 if _, ok := test.Value.(*Plain); ok {
                         continue
                 }
 
                 vt := reflect.TypeOf(test.Value)
                 dest := reflect.New(vt.Elem()).Interface()
-                buffer := bytes.NewBufferString(test.ExpectXML)
-                err := Unmarshal(buffer, dest)
+                err := Unmarshal([]byte(test.ExpectXML), dest)
 
                 switch fix := dest.(type) {
                 case *Feed:
                         fix.Author.InnerXML = ""
                         for i := range fix.Entry {
                                 fix.Entry[i].Author.InnerXML = ""
                         }
                 }
 
                 if err != nil {
                         t.Errorf("#%d: unexpected error: %#v", i, err)
                 } else if got, want := dest, test.Value; !reflect.DeepEqual(got, want) {
                         t.Errorf("#%d: unmarshal(%q):\nhave %#v\nwant %#v", i, test.ExpectXML, got, want)
                 }
         }
 }
 
 func BenchmarkMarshal(b *testing.B) {
-        buf := bytes.NewBuffer(nil)
         for i := 0; i < b.N; i++ {
-                Marshal(buf, atomValue)
-                buf.Truncate(0)
+                Marshal(atomValue)
         }
 }
 
 func BenchmarkUnmarshal(b *testing.B) {
         xml := []byte(atomXml)
         for i := 0; i < b.N; i++ {
-                buffer := bytes.NewBuffer(xml)
-                Unmarshal(buffer, &Feed{})
+                Unmarshal(xml, &Feed{})
         }
 }