code review 7962044: database/sql: optimized []byte copy + []byte(nil) -> *i...

src/pkg/database/sql/convert_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 sql
 
 import (
         "database/sql/driver"
         "fmt"
         "reflect"
@@ skipping 125 matching lines @@
         {s: interface{}(nil), d: &scanptr, wantnil: true},
         {s: int64(42), d: &scanptr, wantptr: &answer},
 
         // To interface{}
         {s: float64(1.5), d: &scaniface, wantiface: float64(1.5)},
         {s: int64(1), d: &scaniface, wantiface: int64(1)},
         {s: "str", d: &scaniface, wantiface: "str"},
         {s: []byte("byteslice"), d: &scaniface, wantiface: []byte("byteslice")},
         {s: true, d: &scaniface, wantiface: true},
         {s: nil, d: &scaniface},
+        {s: []byte(nil), d: &scaniface, wantiface: []byte(nil)},
 }
 
 func intPtrValue(intptr interface{}) interface{} {
         return reflect.Indirect(reflect.Indirect(reflect.ValueOf(intptr))).Int()
 }
 
 func intValue(intptr interface{}) int64 {
         return reflect.Indirect(reflect.ValueOf(intptr)).Int()
 }
 
@@ skipping 58 matching lines @@
                                 errf("want pointer to %v, got %v", *ct.wantptr, intPtrValue(ct.d))
                         }
                 }
                 if ifptr, ok := ct.d.(*interface{}); ok {
                         if !reflect.DeepEqual(ct.wantiface, scaniface) {
                                 errf("want interface %#v, got %#v", ct.wantiface, scaniface)
                                 continue
                         }
                         if srcBytes, ok := ct.s.([]byte); ok {
                                 dstBytes := (*ifptr).([]byte)
-                                if &dstBytes[0] == &srcBytes[0] {
+                                if len(srcBytes) > 0 && &dstBytes[0] == &srcBytes[0] {
                                         errf("copy into interface{} didn't copy []byte data")
                                 }
                         }
                 }
         }
 }
 
 func TestNullString(t *testing.T) {
         var ns NullString
         convertAssign(&ns, []byte("foo"))
@@ skipping 36 matching lines @@
                 }
                 if tt.err != "" {
                         continue
                 }
                 if !reflect.DeepEqual(out, tt.out) {
                         t.Errorf("test %d: %s(%T(%v)) = %v (%T); want %v (%T)",
                                 i, tt.c, tt.in, tt.in, out, out, tt.out, tt.out)
                 }
         }
 }