libgo: Merge to master revision 19184.

The next revision, 19185, renames several runtime files, and
will be handled in a separate change.

From-SVN: r211328

1 files changed, 56 insertions, 0 deletions

diff --git a/libgo/go/database/sql/convert_test.go b/libgo/go/database/sql/convert_test.go
index a39c2c5..6e24830 100644
--- a/libgo/go/database/sql/convert_test.go
+++ b/libgo/go/database/sql/convert_test.go
@@ -8,6 +8,7 @@ import (
 	"database/sql/driver"
 	"fmt"
 	"reflect"
+	"runtime"
 	"testing"
 	"time"
 )
@@ -279,3 +280,58 @@ func TestValueConverters(t *testing.T) {
 		}
 	}
 }
+
+// Tests that assigning to RawBytes doesn't allocate (and also works).
+func TestRawBytesAllocs(t *testing.T) {
+	buf := make(RawBytes, 10)
+	test := func(name string, in interface{}, want string) {
+		if err := convertAssign(&buf, in); err != nil {
+			t.Fatalf("%s: convertAssign = %v", name, err)
+		}
+		match := len(buf) == len(want)
+		if match {
+			for i, b := range buf {
+				if want[i] != b {
+					match = false
+					break
+				}
+			}
+		}
+		if !match {
+			t.Fatalf("%s: got %q (len %d); want %q (len %d)", name, buf, len(buf), want, len(want))
+		}
+	}
+	n := testing.AllocsPerRun(100, func() {
+		test("uint64", uint64(12345678), "12345678")
+		test("uint32", uint32(1234), "1234")
+		test("uint16", uint16(12), "12")
+		test("uint8", uint8(1), "1")
+		test("uint", uint(123), "123")
+		test("int", int(123), "123")
+		test("int8", int8(1), "1")
+		test("int16", int16(12), "12")
+		test("int32", int32(1234), "1234")
+		test("int64", int64(12345678), "12345678")
+		test("float32", float32(1.5), "1.5")
+		test("float64", float64(64), "64")
+		test("bool", false, "false")
+	})
+
+	// The numbers below are only valid for 64-bit interface word sizes,
+	// and gc. With 32-bit words there are more convT2E allocs, and
+	// with gccgo, only pointers currently go in interface data.
+	// So only care on amd64 gc for now.
+	measureAllocs := runtime.GOARCH == "amd64" && runtime.Compiler == "gc"
+
+	if n > 0.5 && measureAllocs {
+		t.Fatalf("allocs = %v; want 0", n)
+	}
+
+	// This one involves a convT2E allocation, string -> interface{}
+	n = testing.AllocsPerRun(100, func() {
+		test("string", "foo", "foo")
+	})
+	if n > 1.5 && measureAllocs {
+		t.Fatalf("allocs = %v; want max 1", n)
+	}
+}