From 64f4e0b197fcfe089b34e418e7f4810782a3e10e Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 7 Jul 2009 11:03:12 -0700 Subject: [PATCH] update reflect supporting functions, tests to use new reflect interface. also make tests a real gotest. depends on CL 31107 R=r DELTA=582 (56 added, 194 deleted, 332 changed) OCL=31108 CL=31279 --- src/pkg/reflect/all_test.go | 585 ++++++++++++++++------------------- src/pkg/reflect/deepequal.go | 56 ++-- src/pkg/reflect/tostring.go | 245 ++++----------- 3 files changed, 374 insertions(+), 512 deletions(-) diff --git a/src/pkg/reflect/all_test.go b/src/pkg/reflect/all_test.go index fcbe473bef..56f0deb6c2 100644 --- a/src/pkg/reflect/all_test.go +++ b/src/pkg/reflect/all_test.go @@ -12,312 +12,253 @@ import ( "unsafe"; ) -var doprint bool = false +type integer int +type T struct { a int; b float64; c string; d *int } + +type pair struct { + i interface{}; + s string; +} -func is_digit(c uint8) bool { +func isDigit(c uint8) bool { return '0' <= c && c <= '9' } -// streq, but '@' in t matches a string of digits -func match(s, t string) bool { - for i, j := 0, 0; i < len(s) && j < len(t); i, j = i+1, j+1 { - if s[i] == t[j] { - continue +func assert(t *testing.T, s, want string) { + if s != want { + t.Errorf("have %#q want %#q", s, want); + } +} + +func typestring(i interface{}) string { + return Typeof(i).String(); +} + +var typeTests = []pair { + pair { struct { x int }{}, "int" }, + pair { struct { x int8 }{}, "int8" }, + pair { struct { x int16 }{}, "int16" }, + pair { struct { x int32 }{}, "int32" }, + pair { struct { x int64 }{}, "int64" }, + pair { struct { x uint }{}, "uint" }, + pair { struct { x uint8 }{}, "uint8" }, + pair { struct { x uint16 }{}, "uint16" }, + pair { struct { x uint32 }{}, "uint32" }, + pair { struct { x uint64 }{}, "uint64" }, + pair { struct { x float }{}, "float" }, + pair { struct { x float32 }{}, "float32" }, + pair { struct { x float64 }{}, "float64" }, + pair { struct { x int8 }{}, "int8" }, + pair { struct { x (**int8) }{}, "**int8" }, + pair { struct { x (**reflect.integer) }{}, "**reflect.integer" }, + pair { struct { x ([32]int32) }{}, "[32]int32" }, + pair { struct { x ([]int8) }{}, "[]int8" }, + pair { struct { x (map[string]int32) }{}, "map[string] int32" }, + pair { struct { x (chan<-string) }{}, "chan<- string" }, + pair { struct { x struct {c chan *int32; d float32} }{}, "struct { c chan *int32; d float32 }" }, + pair { struct { x (func(a int8, b int32)) }{}, "func(int8, int32)" }, + pair { struct { x struct {c func(chan *reflect.integer, *int8)} }{}, "struct { c func(chan *reflect.integer, *int8) }" }, + pair { struct { x struct {a int8; b int32} }{}, "struct { a int8; b int32 }" }, + pair { struct { x struct {a int8; b int8; b int32} }{}, "struct { a int8; b int8; b int32 }" }, + pair { struct { x struct {a int8; b int8; c int8; b int32} }{}, "struct { a int8; b int8; c int8; b int32 }" }, + pair { struct { x struct {a int8; b int8; c int8; d int8; b int32} }{}, "struct { a int8; b int8; c int8; d int8; b int32 }" }, + pair { struct { x struct {a int8; b int8; c int8; d int8; e int8; b int32} }{}, "struct { a int8; b int8; c int8; d int8; e int8; b int32 }" }, + pair { struct { x struct {a int8 "hi there"; } }{}, `struct { a int8 "hi there" }` }, + pair { struct { x struct {a int8 "hi \x00there\t\n\"\\"; } }{}, `struct { a int8 "hi \x00there\t\n\"\\" }` }, + pair { struct { x struct {f func(args ...)} }{}, "struct { f func(...) }" }, + pair { struct { x (interface { a(func(func(int)(int))(func(func(int))(int))); b() }) }{}, "interface { a (func(func(int) (int)) (func(func(int)) (int))); b () }" }, +} + +var valueTests = []pair { + pair { (int8)(0), "8" }, + pair { (int16)(0), "16" }, + pair { (int32)(0), "32" }, + pair { (int64)(0), "64" }, + pair { (uint8)(0), "8" }, + pair { (uint16)(0), "16" }, + pair { (uint32)(0), "32" }, + pair { (uint64)(0), "64" }, + pair { (float32)(0), "32.1" }, + pair { (float64)(0), "64.2" }, + pair { (string)(""), "stringy cheese" }, + pair { (bool)(false), "true" }, + pair { (*int8)(nil), "*int8(0)" }, + pair { (**int8)(nil), "**int8(0)" }, + pair { ([5]int32){}, "[5]int32{0, 0, 0, 0, 0}" }, + pair { (**reflect.integer)(nil), "**reflect.integer(0)" }, + pair { (map[string]int32)(nil), "map[string] int32{}" }, + pair { (chan<-string)(nil), "chan<- string" }, + pair { (struct {c chan *int32; d float32}){}, "struct { c chan *int32; d float32 }{chan *int32, 0}" }, + pair { (func(a int8, b int32))(nil), "func(int8, int32)(0)" }, + pair { (struct {c func(chan *reflect.integer, *int8)}){}, "struct { c func(chan *reflect.integer, *int8) }{func(chan *reflect.integer, *int8)(0)}" }, + pair { (struct {a int8; b int32}){}, "struct { a int8; b int32 }{0, 0}" }, + pair { (struct {a int8; b int8; b int32}){}, "struct { a int8; b int8; b int32 }{0, 0, 0}" }, +} + +func testType(t *testing.T, i int, typ Type, want string) { + s := typ.String(); + if s != want { + t.Errorf("#%d: have %#q, want %#q", i, s, want); + } +} + +func TestTypes(t *testing.T) { + for i, tt := range typeTests { + testType(t, i, NewValue(tt.i).(*StructValue).Field(0).Type(), tt.s); + } +} + +func TestValue(t *testing.T) { + for i, tt := range valueTests { + v := NewValue(tt.i); + switch v := v.(type) { + case *reflect.IntValue: + v.Set(132); + case *reflect.Int8Value: + v.Set(8); + case *reflect.Int16Value: + v.Set(16); + case *reflect.Int32Value: + v.Set(32); + case *reflect.Int64Value: + v.Set(64); + case *reflect.UintValue: + v.Set(132); + case *reflect.Uint8Value: + v.Set(8); + case *reflect.Uint16Value: + v.Set(16); + case *reflect.Uint32Value: + v.Set(32); + case *reflect.Uint64Value: + v.Set(64); + case *reflect.FloatValue: + v.Set(3200.0); + case *reflect.Float32Value: + v.Set(32.1); + case *reflect.Float64Value: + v.Set(64.2); + case *reflect.StringValue: + v.Set("stringy cheese"); + case *reflect.BoolValue: + v.Set(true); } - if is_digit(s[i]) && t[j] == '@' { - for is_digit(s[i+1]) { - i++ - } - } else { - return false + s := valueToString(v); + if s != tt.s { + t.Errorf("#%d: have %#q, want %#q", i, s, tt.s); } } - return true; -} - -func assert(s, t string) { - if doprint { - println(t) - } - if !match(s, t) { - panicln(s, t) - } -} - -func typedump(s, t string) { - typ := ParseTypeString("", s); - assert(typeToString(typ, true), t); -} - -func valuedump(s, t string) { - typ := ParseTypeString("", s); - v := NewZeroValue(typ); - if v == nil { - panicln("valuedump", s); - } - switch v.Kind() { - case IntKind: - v.(IntValue).Set(132); - case Int8Kind: - v.(Int8Value).Set(8); - case Int16Kind: - v.(Int16Value).Set(16); - case Int32Kind: - v.(Int32Value).Set(32); - case Int64Kind: - v.(Int64Value).Set(64); - case UintKind: - v.(UintValue).Set(132); - case Uint8Kind: - v.(Uint8Value).Set(8); - case Uint16Kind: - v.(Uint16Value).Set(16); - case Uint32Kind: - v.(Uint32Value).Set(32); - case Uint64Kind: - v.(Uint64Value).Set(64); - case FloatKind: - v.(FloatValue).Set(3200.0); - case Float32Kind: - v.(Float32Value).Set(32.1); - case Float64Kind: - v.(Float64Value).Set(64.2); - case StringKind: - v.(StringValue).Set("stringy cheese"); - case BoolKind: - v.(BoolValue).Set(true); - } - assert(valueToString(v), t); } -type T struct { a int; b float64; c string; d *int } +var _i = 7; + +var valueToStringTests = []pair { + pair { 123, "123" }, + pair { 123.4, "123.4" }, + pair { byte(123), "123" }, + pair { "abc", "abc" }, + pair { T{123, 456.75, "hello", &_i}, "reflect.T{123, 456.75, hello, *int(&7)}" }, + pair { new(chan *T), "*chan *reflect.T(&chan *reflect.T)" }, + pair { [10]int{1,2,3,4,5,6,7,8,9,10}, "[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}" }, + pair { &[10]int{1,2,3,4,5,6,7,8,9,10}, "*[10]int(&[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})" }, + pair { []int{1,2,3,4,5,6,7,8,9,10}, "[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}" }, + pair { &[]int{1,2,3,4,5,6,7,8,9,10}, "*[]int(&[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})" } +} -func TestAll(tt *testing.T) { // TODO(r): wrap up better - var s string; - var t Type; - - // Types - typedump("missing", "$missing$"); - typedump("int", "int"); - typedump("int8", "int8"); - typedump("int16", "int16"); - typedump("int32", "int32"); - typedump("int64", "int64"); - typedump("uint", "uint"); - typedump("uint8", "uint8"); - typedump("uint16", "uint16"); - typedump("uint32", "uint32"); - typedump("uint64", "uint64"); - typedump("float", "float"); - typedump("float32", "float32"); - typedump("float64", "float64"); - typedump("int8", "int8"); - typedump("whoknows.whatsthis", "$missing$"); - typedump("**int8", "**int8"); - typedump("**P.integer", "**P.integer"); - typedump("[32]int32", "[32]int32"); - typedump("[]int8", "[]int8"); - typedump("map[string]int32", "map[string]int32"); - typedump("chan<-string", "chan<-string"); - typedump("struct {c chan *int32; d float32}", "struct{c chan*int32; d float32}"); - typedump("func(a int8, b int32)", "func(a int8, b int32)"); - typedump("struct {c func(? chan *P.integer, ? *int8)}", "struct{c func(chan*P.integer, *int8)}"); - typedump("struct {a int8; b int32}", "struct{a int8; b int32}"); - typedump("struct {a int8; b int8; b int32}", "struct{a int8; b int8; b int32}"); - typedump("struct {a int8; b int8; c int8; b int32}", "struct{a int8; b int8; c int8; b int32}"); - typedump("struct {a int8; b int8; c int8; d int8; b int32}", "struct{a int8; b int8; c int8; d int8; b int32}"); - typedump("struct {a int8; b int8; c int8; d int8; e int8; b int32}", "struct{a int8; b int8; c int8; d int8; e int8; b int32}"); - typedump("struct {a int8 \"hi there\"; }", "struct{a int8 \"hi there\"}"); - typedump("struct {a int8 \"hi \\x00there\\t\\n\\\"\\\\\"; }", "struct{a int8 \"hi \\x00there\\t\\n\\\"\\\\\"}"); - typedump("struct {f func(args ...)}", "struct{f func(args ...)}"); - typedump("interface { a(? func(? func(? int) int) func(? func(? int)) int); b() }", "interface{a (func(func(int)(int))(func(func(int))(int))); b ()}"); - - // Values - valuedump("int8", "8"); - valuedump("int16", "16"); - valuedump("int32", "32"); - valuedump("int64", "64"); - valuedump("uint8", "8"); - valuedump("uint16", "16"); - valuedump("uint32", "32"); - valuedump("uint64", "64"); - valuedump("float32", "32.1"); - valuedump("float64", "64.2"); - valuedump("string", "stringy cheese"); - valuedump("bool", "true"); - valuedump("*int8", "*int8(0)"); - valuedump("**int8", "**int8(0)"); - valuedump("[5]int32", "[5]int32{0, 0, 0, 0, 0}"); - valuedump("**P.integer", "**P.integer(0)"); - valuedump("map[string]int32", "map[string]int32{}"); - valuedump("chan<-string", "chan<-string"); - valuedump("struct {c chan *int32; d float32}", "struct{c chan*int32; d float32}{chan*int32, 0}"); - valuedump("func(a int8, b int32)", "func(a int8, b int32)(0)"); - valuedump("struct {c func(? chan *P.integer, ? *int8)}", "struct{c func(chan*P.integer, *int8)}{func(chan*P.integer, *int8)(0)}"); - valuedump("struct {a int8; b int32}", "struct{a int8; b int32}{0, 0}"); - valuedump("struct {a int8; b int8; b int32}", "struct{a int8; b int8; b int32}{0, 0, 0}"); - - { var tmp = 123; - value := NewValue(tmp); - assert(valueToString(value), "123"); - } - { var tmp = 123.4; - value := NewValue(tmp); - assert(valueToString(value), "123.4"); - } - { - var tmp = byte(123); - value := NewValue(tmp); - assert(valueToString(value), "123"); - assert(typeToString(value.Type(), false), "uint8"); - } - { var tmp = "abc"; - value := NewValue(tmp); - assert(valueToString(value), "abc"); - } - { - var i int = 7; - var tmp = &T{123, 456.75, "hello", &i}; - value := NewValue(tmp); - assert(valueToString(value.(PtrValue).Sub()), "reflect.T{123, 456.75, hello, *int(@)}"); - } - { - type C chan *T; // TODO: should not be necessary - var tmp = new(C); - value := NewValue(tmp); - assert(valueToString(value), "*reflect.C·all_test(@)"); - } -// { -// type A [10]int; -// var tmp A = A{1,2,3,4,5,6,7,8,9,10}; -// value := NewValue(&tmp); -// assert(valueToString(value.(PtrValue).Sub()), "reflect.A·all_test{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"); -// value.(PtrValue).Sub().(ArrayValue).Elem(4).(IntValue).Set(123); -// assert(valueToString(value.(PtrValue).Sub()), "reflect.A·all_test{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}"); -// } - { - type AA []int; - var tmp = AA{1,2,3,4,5,6,7,8,9,10}; - value := NewValue(&tmp); // TODO: NewValue(tmp) too - assert(valueToString(value.(PtrValue).Sub()), "reflect.AA·all_test{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"); - value.(PtrValue).Sub().(ArrayValue).Elem(4).(IntValue).Set(123); - assert(valueToString(value.(PtrValue).Sub()), "reflect.AA·all_test{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}"); - } - - { - var ip *int32; - var i int32 = 1234; - vip := NewValue(&ip); - vi := NewValue(i); - vip.(PtrValue).Sub().(PtrValue).SetSub(vi); - if *ip != 1234 { - panicln("SetSub failure", *ip); +func TestValueToString(t *testing.T) { + for i, test := range valueToStringTests { + s := valueToString(NewValue(test.i)); + if s != test.s { + t.Errorf("#%d: have %#q, want %#q", i, s, test.s); } } +} - var pt PtrType; - var st StructType; - var mt MapType; - var at ArrayType; - var ct ChanType; - var name string; - var typ Type; - var tag string; - var offset int; - - // Type strings - t = ParseTypeString("", "int8"); - assert(t.String(), "int8"); - - t = ParseTypeString("", "*int8"); - assert(t.String(), "*int8"); - pt = t.(PtrType); - assert(pt.Sub().String(), "int8"); - - t = ParseTypeString("", "*struct {c chan *int32; d float32}"); - assert(t.String(), "*struct {c chan *int32; d float32}"); - pt = t.(PtrType); - assert(pt.Sub().String(), "struct {c chan *int32; d float32}"); - st = pt.Sub().(StructType); - name, typ, tag, offset = st.Field(0); - assert(typ.String(), "chan *int32"); - name, typ, tag, offset = st.Field(1); - assert(typ.String(), "float32"); - - t = ParseTypeString("", "interface {a() *int}"); - assert(t.String(), "interface {a() *int}"); - - t = ParseTypeString("", "func(a int8, b int32)"); - assert(t.String(), "func(a int8, b int32)"); - - t = ParseTypeString("", "func(a int8, b int32) float"); - assert(t.String(), "func(a int8, b int32) float"); - - t = ParseTypeString("", "func(a int8, b int32) (a float, b float)"); - assert(t.String(), "func(a int8, b int32) (a float, b float)"); - - t = ParseTypeString("", "[32]int32"); - assert(t.String(), "[32]int32"); - at = t.(ArrayType); - assert(at.Elem().String(), "int32"); - - t = ParseTypeString("", "map[string]*int32"); - assert(t.String(), "map[string]*int32"); - mt = t.(MapType); - assert(mt.Key().String(), "string"); - assert(mt.Elem().String(), "*int32"); - - t = ParseTypeString("", "chan<-string"); - assert(t.String(), "chan<-string"); - ct = t.(ChanType); - assert(ct.Elem().String(), "string"); - - // make sure tag strings are not part of element type - t = ParseTypeString("", "struct{d []uint32 \"TAG\"}"); - st = t.(StructType); - name, typ, tag, offset = st.Field(0); - assert(typ.String(), "[]uint32"); +func TestArrayElemSet(t *testing.T) { + v := NewValue([10]int{1,2,3,4,5,6,7,8,9,10}); + v.(*ArrayValue).Elem(4).(*IntValue).Set(123); + s := valueToString(v); + const want = "[10]int{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}"; + if s != want { + t.Errorf("[10]int: have %#q want %#q", s, want); + } - t = ParseTypeString("", "[]int32"); - v := NewSliceValue(t.(ArrayType), 5, 10); - t1 := ParseTypeString("", "*[]int32"); - v1 := NewZeroValue(t1); - if v1 == nil { panic("V1 is nil"); } - v1.(PtrValue).SetSub(v); - a := *v1.Interface().(*[]int32); - println(a, len(a), cap(a)); - for i := 0; i < len(a); i++ { - v.Elem(i).(Int32Value).Set(int32(i)); + v = NewValue([]int{1,2,3,4,5,6,7,8,9,10}); + v.(*SliceValue).Elem(4).(*IntValue).Set(123); + s = valueToString(v); + const want1 = "[]int{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}"; + if s != want1 { + t.Errorf("[]int: have %#q want %#q", s, want1); } - for i := 0; i < len(a); i++ { - println(a[i]); +} + +func TestPtrPointTo(t *testing.T) { + var ip *int32; + var i int32 = 1234; + vip := NewValue(&ip); + vi := NewValue(i); + vip.(*PtrValue).Elem().(*PtrValue).PointTo(vi); + if *ip != 1234 { + t.Errorf("got %d, want 1234", *ip); } } +func TestAll(t *testing.T) { // TODO(r): wrap up better + testType(t, 1, Typeof((int8)(0)), "int8"); + testType(t, 2, Typeof((*int8)(nil)).(*PtrType).Elem(), "int8"); + + typ := Typeof((*struct{c chan *int32; d float32})(nil)); + testType(t, 3, typ, "*struct { c chan *int32; d float32 }"); + etyp := typ.(*PtrType).Elem(); + testType(t, 4, etyp, "struct { c chan *int32; d float32 }"); + styp := etyp.(*StructType); + f := styp.Field(0); + testType(t, 5, f.Type, "chan *int32"); + f = styp.Field(1); + testType(t, 6, f.Type, "float32"); + + typ = Typeof(([32]int32)(nil)); + testType(t, 7, typ, "[32]int32"); + testType(t, 8, typ.(*ArrayType).Elem(), "int32"); + + typ = Typeof((map[string]*int32)(nil)); + testType(t, 9, typ, "map[string] *int32"); + mtyp := typ.(*MapType); + testType(t, 10, mtyp.Key(), "string"); + testType(t, 11, mtyp.Elem(), "*int32"); + + typ = Typeof((chan<-string)(nil)); + testType(t, 12, typ, "chan<- string"); + testType(t, 13, typ.(*ChanType).Elem(), "string"); + + // make sure tag strings are not part of element type + typ = Typeof(struct{d []uint32 "TAG"}{}).(*StructType).Field(0).Type; + testType(t, 14, typ, "[]uint32"); +} + func TestInterfaceGet(t *testing.T) { var inter struct { e interface{ } }; inter.e = 123.456; v1 := NewValue(&inter); - v2 := v1.(PtrValue).Sub().(StructValue).Field(0); - assert(v2.Type().String(), "interface { }"); - i2 := v2.(InterfaceValue).Get(); + v2 := v1.(*PtrValue).Elem().(*StructValue).Field(0); + assert(t, v2.Type().String(), "interface { }"); + i2 := v2.(*InterfaceValue).Interface(); v3 := NewValue(i2); - assert(v3.Type().String(), "float"); + assert(t, v3.Type().String(), "float"); } func TestInterfaceValue(t *testing.T) { var inter struct { e interface{ } }; inter.e = 123.456; v1 := NewValue(&inter); - v2 := v1.(PtrValue).Sub().(StructValue).Field(0); - assert(v2.Type().String(), "interface { }"); - v3 := v2.(InterfaceValue).Value(); - assert(v3.Type().String(), "float"); + v2 := v1.(*PtrValue).Elem().(*StructValue).Field(0); + assert(t, v2.Type().String(), "interface { }"); + v3 := v2.(*InterfaceValue).Elem(); + assert(t, v3.Type().String(), "float"); i3 := v2.Interface(); if f, ok := i3.(float); !ok { - a, typ, c := unsafe.Reflect(i3); - t.Error("v2.Interface() did not return float, got ", typ); + t.Error("v2.Interface() did not return float, got ", Typeof(i3)); } } @@ -326,7 +267,7 @@ func TestFunctionValue(t *testing.T) { if v.Interface() != v.Interface() { t.Fatalf("TestFunction != itself"); } - assert(v.Type().String(), "func()"); + assert(t, v.Type().String(), "func()"); } func TestCopyArray(t *testing.T) { @@ -340,21 +281,25 @@ func TestCopyArray(t *testing.T) { t.Fatalf("b != c before test"); } } + aa := va.(*PtrValue).Elem().(*SliceValue); + ab := vb.(*PtrValue).Elem().(*SliceValue); for tocopy := 1; tocopy <= 7; tocopy++ { - vb.(PtrValue).Sub().(ArrayValue).CopyFrom(va.(PtrValue).Sub().(ArrayValue), tocopy); + aa.SetLen(tocopy); + ArrayCopy(ab, aa); + aa.SetLen(8); for i := 0; i < tocopy; i++ { if a[i] != b[i] { - t.Errorf("1 tocopy=%d a[%d]=%d, b[%d]=%d", + t.Errorf("(i) tocopy=%d a[%d]=%d, b[%d]=%d", tocopy, i, a[i], i, b[i]); } } for i := tocopy; i < len(b); i++ { if b[i] != c[i] { if i < len(a) { - t.Errorf("2 tocopy=%d a[%d]=%d, b[%d]=%d, c[%d]=%d", + t.Errorf("(ii) tocopy=%d a[%d]=%d, b[%d]=%d, c[%d]=%d", tocopy, i, a[i], i, b[i], i, c[i]); } else { - t.Errorf("3 tocopy=%d b[%d]=%d, c[%d]=%d", + t.Errorf("(iii) tocopy=%d b[%d]=%d, c[%d]=%d", tocopy, i, b[i], i, c[i]); } } else { @@ -369,7 +314,7 @@ func TestBigUnnamedStruct(t *testing.T) { v := NewValue(b); b1 := v.Interface().(struct{a,b,c,d int64}); if b1.a != b.a || b1.b != b.b || b1.c != b.c || b1.d != b.d { - t.Errorf("NewValue(%v).Interface().(Big) = %v", b, b1); + t.Errorf("NewValue(%v).Interface().(*Big) = %v", b, b1); } } @@ -452,6 +397,9 @@ func TestDeepEqual(t *testing.T) { func TestTypeof(t *testing.T) { for i, test := range deepEqualTests { v := NewValue(test.a); + if v == nil { + continue; + } typ := Typeof(test.a); if typ != v.Type() { t.Errorf("Typeof(%v) = %v, but NewValue(%v).Type() = %v", test.a, typ, test.a, v.Type()); @@ -492,10 +440,10 @@ func TestDeepEqualComplexStructInequality(t *testing.T) { func check2ndField(x interface{}, offs uintptr, t *testing.T) { - s := NewValue(x).(StructValue); - name, ftype, tag, reflect_offset := s.Type().(StructType).Field(1); - if uintptr(reflect_offset) != offs { - t.Error("mismatched offsets in structure alignment:", reflect_offset, offs); + s := NewValue(x).(*StructValue); + f := s.Type().(*StructType).Field(1); + if f.Offset != offs { + t.Error("mismatched offsets in structure alignment:", f.Offset, offs); } } @@ -524,19 +472,19 @@ func TestAlignment(t *testing.T) { check2ndField(x1, uintptr(unsafe.Pointer(&x1.f)) - uintptr(unsafe.Pointer(&x1)), t); } -type Nillable interface { +type IsNiller interface { IsNil() bool } func Nil(a interface{}, t *testing.T) { - n := NewValue(a).(Nillable); + n := NewValue(a).(*StructValue).Field(0).(IsNiller); if !n.IsNil() { t.Errorf("%v should be nil", a) } } func NotNil(a interface{}, t *testing.T) { - n := NewValue(a).(Nillable); + n := NewValue(a).(*StructValue).Field(0).(IsNiller); if n.IsNil() { t.Errorf("value of type %v should not be nil", NewValue(a).Type().String()) } @@ -544,45 +492,62 @@ func NotNil(a interface{}, t *testing.T) { func TestIsNil(t *testing.T) { // These do not implement IsNil - doNotNil := []string{"int", "float32", "struct { a int }"}; - // These do implement IsNil - doNil := []string{"*int", "interface{}", "map[string]int", "func() bool", "chan int", "[]string"}; + doNotNil := []interface{}{ int(0), float32(0), struct{a int}{} }; for i, ts := range doNotNil { - ty := ParseTypeString("", ts); - v := NewZeroValue(ty); - if nilable, ok := v.(Nillable); ok { + ty := Typeof(ts); + v := MakeZero(ty); + if nilable, ok := v.(IsNiller); ok { t.Errorf("%s is nilable; should not be", ts) } } + // These do implement IsNil. + // Wrap in extra struct to hide interface type. + doNil := []interface{}{ + struct{x *int}{}, + struct{x interface{}}{}, + struct{x map[string]int}{}, + struct{x func()bool}{}, + struct{x chan int}{}, + struct{x []string}{} + }; for i, ts := range doNil { - ty := ParseTypeString("", ts); - v := NewZeroValue(ty); - if nilable, ok := v.(Nillable); !ok { + ty := Typeof(ts).(*StructType).Field(0).Type; + v := MakeZero(ty); + if nilable, ok := v.(IsNiller); !ok { t.Errorf("%s %T is not nilable; should be", ts, v) } } + // Check the implementations - var pi *int; + var pi struct {x *int} Nil(pi, t); - pi = new(int); + pi.x = new(int); NotNil(pi, t); - var si []int; + var si struct {x []int} Nil(si, t); - si = make([]int, 10); + si.x = make([]int, 10); NotNil(si, t); - // TODO: map and chan don't work yet + var ci struct {x chan int} + Nil(ci, t); + ci.x = make(chan int); + NotNil(ci, t); + + var mi struct {x map[int]int} + Nil(mi, t); + mi.x = make(map[int]int); + NotNil(mi, t); - var ii interface {}; + var ii struct {x interface {}} Nil(ii, t); - ii = pi; + ii.x = 2; NotNil(ii, t); - var fi func(t *testing.T); + var fi struct {x func(t *testing.T)} Nil(fi, t); - fi = TestIsNil; + fi.x = TestIsNil; NotNil(fi, t); } @@ -592,7 +557,7 @@ func TestInterfaceExtraction(t *testing.T) { } s.w = os.Stdout; - v := Indirect(NewValue(&s)).(StructValue).Field(0).Interface(); + v := Indirect(NewValue(&s)).(*StructValue).Field(0).Interface(); if v != s.w.(interface{}) { t.Errorf("Interface() on interface: ", v, s.w); } @@ -612,7 +577,7 @@ func TestInterfaceEditing(t *testing.T) { // and setting that copy to "bye" should // not change the value stored in i. - v.(StringValue).Set("bye"); + v.(*StringValue).Set("bye"); if i.(string) != "hello" { t.Errorf(`Set("bye") changed i to %s`, i.(string)); } @@ -620,7 +585,7 @@ func TestInterfaceEditing(t *testing.T) { // the same should be true of smaller items. i = 123; v = NewValue(i); - v.(IntValue).Set(234); + v.(*IntValue).Set(234); if i.(int) != 123 { t.Errorf("Set(234) changed i to %d", i.(int)); } @@ -628,7 +593,7 @@ func TestInterfaceEditing(t *testing.T) { func TestNilPtrValueSub(t *testing.T) { var pi *int; - if pv := NewValue(pi).(PtrValue); pv.Sub() != nil { - t.Error("NewValue((*int)(nil)).(PtrValue).Sub() != nil"); + if pv := NewValue(pi).(*PtrValue); pv.Elem() != nil { + t.Error("NewValue((*int)(nil)).(*PtrValue).Elem() != nil"); } } diff --git a/src/pkg/reflect/deepequal.go b/src/pkg/reflect/deepequal.go index d4299edb57..08c3edab38 100644 --- a/src/pkg/reflect/deepequal.go +++ b/src/pkg/reflect/deepequal.go @@ -29,14 +29,14 @@ func deepValueEqual(v1, v2 Value, visited map[uintptr]*visit, depth int) bool { if v2 == nil { return false } - if !equalType(v1.Type(), v2.Type()) { + if v1.Type() != v2.Type() { return false; } // if depth > 10 { panic("deepValueEqual") } // for debugging - addr1 := uintptr(v1.Addr()); - addr2 := uintptr(v2.Addr()); + addr1 := v1.Addr(); + addr2 := v2.Addr(); if addr1 > addr2 { // Canonicalize order to reduce number of entries in visited. addr1, addr2 = addr2, addr1; @@ -60,11 +60,11 @@ func deepValueEqual(v1, v2 Value, visited map[uintptr]*visit, depth int) bool { // Remember for later. visited[h] = &visit{addr1, addr2, typ, seen}; - switch v1.Kind() { - case ArrayKind: - arr1 := v1.(ArrayValue); - arr2 := v2.(ArrayValue); - if arr1.IsSlice() != arr2.IsSlice() || arr1.Len() != arr2.Len() { + switch v := v1.(type) { + case *ArrayValue: + arr1 := v; + arr2 := v2.(*ArrayValue); + if arr1.Len() != arr2.Len() { return false; } for i := 0; i < arr1.Len(); i++ { @@ -73,25 +73,34 @@ func deepValueEqual(v1, v2 Value, visited map[uintptr]*visit, depth int) bool { } } return true; - case InterfaceKind: - i1 := v1.(InterfaceValue).Get(); - i2 := v2.(InterfaceValue).Get(); + case *SliceValue: + arr1 := v; + arr2 := v2.(*SliceValue); + if arr1.Len() != arr2.Len() { + return false; + } + for i := 0; i < arr1.Len(); i++ { + if !deepValueEqual(arr1.Elem(i), arr2.Elem(i), visited, depth+1) { + return false; + } + } + return true; + case *InterfaceValue: + i1 := v.Interface(); + i2 := v2.Interface(); if i1 == nil || i2 == nil { return i1 == i2; } return deepValueEqual(NewValue(i1), NewValue(i2), visited, depth+1); - case MapKind: + case *MapValue: // TODO(dnadasi): Implement this fully once MapValue is implemented return v1.Interface() == v2.Interface(); - case PtrKind: - return deepValueEqual(v1.(PtrValue).Sub(), v2.(PtrValue).Sub(), visited, depth+1); - case StructKind: - struct1 := v1.(StructValue); - struct2 := v2.(StructValue); - if struct1.Len() != struct2.Len() { - return false; - } - for i := 0; i < struct1.Len(); i++ { + case *PtrValue: + return deepValueEqual(v.Elem(), v2.(*PtrValue).Elem(), visited, depth+1); + case *StructValue: + struct1 := v; + struct2 := v2.(*StructValue); + for i, n:= 0, v.NumField(); i < n; i++ { if !deepValueEqual(struct1.Field(i), struct2.Field(i), visited, depth+1) { return false; } @@ -112,7 +121,10 @@ func deepValueEqual(v1, v2 Value, visited map[uintptr]*visit, depth int) bool { func DeepEqual(a1, a2 interface{}) bool { v1 := NewValue(a1); v2 := NewValue(a2); - if !equalType(v1.Type(), v2.Type()) { + if v1 == nil { + return v1 == v2; + } + if v1.Type() != v2.Type() { return false; } return deepValueEqual(v1, v2, make(map[uintptr]*visit), 0); diff --git a/src/pkg/reflect/tostring.go b/src/pkg/reflect/tostring.go index a74fe32639..b9ada7b50e 100644 --- a/src/pkg/reflect/tostring.go +++ b/src/pkg/reflect/tostring.go @@ -14,181 +14,66 @@ import ( "strconv"; ) -func typeToString(typ Type, expand bool) string -func valueToString(val Value) string - -func doubleQuote(s string) string { - out := "\""; - for i := 0; i < len(s); i++ { - c := s[i]; - switch c { - case '\n': - out += `\n`; - case '\t': - out += `\t`; - case '\x00': - out += `\x00`; - case '"': - out += `\"`; - case '\\': - out += `\\`; - default: - out += string(c); - } - } - out += "\""; - return out; -} - -type hasFields interface { - Field(i int) (name string, typ Type, tag string, offset int); - Len() int; -} - -func typeFieldsToString(t hasFields, sep string, iface bool) string { - var str string; - for i := 0; i < t.Len(); i++ { - str1, typ, tag, offset := t.Field(i); - if str1 != "" { - str1 += " " - } - str2 := typeToString(typ, false); - if iface && str2[0:4] == "func" { - str2 = str2[4:len(str2)] - } - str1 += str2; - if tag != "" { - str1 += " " + doubleQuote(tag); - } - if i < t.Len() - 1 { - str1 += sep + " "; - } - str += str1; - } - return str; -} - -// typeToString returns a textual representation of typ. The expand -// flag specifies whether to expand the contents of type names; if false, -// the name itself is used as the representation. -// Meant for debugging only; typ.String() serves for most purposes. -func typeToString(typ Type, expand bool) string { - var str string; - if name := typ.Name(); !expand && name != "" { - return name - } - switch typ.Kind() { - case MissingKind: - return "$missing$"; - case IntKind, Int8Kind, Int16Kind, Int32Kind, Int64Kind, - UintKind, Uint8Kind, Uint16Kind, Uint32Kind, Uint64Kind, - FloatKind, Float32Kind, Float64Kind, - StringKind, - DotDotDotKind: - return typ.Name(); - case PtrKind: - p := typ.(PtrType); - return "*" + typeToString(p.Sub(), false); - case ArrayKind: - a := typ.(ArrayType); - if a.IsSlice() { - str = "[]" - } else { - str = "[" + strconv.Itoa64(int64(a.Len())) + "]" - } - return str + typeToString(a.Elem(), false); - case MapKind: - m := typ.(MapType); - str = "map[" + typeToString(m.Key(), false) + "]"; - return str + typeToString(m.Elem(), false); - case ChanKind: - c := typ.(ChanType); - switch c.Dir() { - case RecvDir: - str = "<-chan"; - case SendDir: - str = "chan<-"; - case BothDir: - str = "chan"; - default: - panicln("reflect.typeToString: unknown chan direction"); - } - return str + typeToString(c.Elem(), false); - case StructKind: - return "struct{" + typeFieldsToString(typ.(StructType), ";", false) + "}"; - case InterfaceKind: - return "interface{" + typeFieldsToString(typ.(InterfaceType), ";", true) + "}"; - case FuncKind: - f := typ.(FuncType); - str = "func(" + typeFieldsToString(f.In(), ",", false) + ")"; - if f.Out() != nil { - str += "(" + typeFieldsToString(f.Out(), ",", false) + ")"; - } - return str; - default: - panicln("reflect.typeToString: can't print type ", typ.Kind()); - } - return "reflect.typeToString: can't happen"; -} - -// TODO: want an unsigned one too -func integer(v int64) string { - return strconv.Itoa64(v); -} - // valueToString returns a textual representation of the reflection value val. // For debugging only. func valueToString(val Value) string { var str string; + if val == nil { + return ""; + } typ := val.Type(); - switch val.Kind() { - case MissingKind: - return "missing"; - case IntKind: - return integer(int64(val.(IntValue).Get())); - case Int8Kind: - return integer(int64(val.(Int8Value).Get())); - case Int16Kind: - return integer(int64(val.(Int16Value).Get())); - case Int32Kind: - return integer(int64(val.(Int32Value).Get())); - case Int64Kind: - return integer(int64(val.(Int64Value).Get())); - case UintKind: - return integer(int64(val.(UintValue).Get())); - case Uint8Kind: - return integer(int64(val.(Uint8Value).Get())); - case Uint16Kind: - return integer(int64(val.(Uint16Value).Get())); - case Uint32Kind: - return integer(int64(val.(Uint32Value).Get())); - case Uint64Kind: - return integer(int64(val.(Uint64Value).Get())); - case FloatKind: + switch val := val.(type) { + case *IntValue: + return strconv.Uitoa64(uint64(val.Get())); + case *Int8Value: + return strconv.Itoa64(int64(val.Get())); + case *Int16Value: + return strconv.Itoa64(int64(val.Get())); + case *Int32Value: + return strconv.Itoa64(int64(val.Get())); + case *Int64Value: + return strconv.Itoa64(int64(val.Get())); + case *UintValue: + return strconv.Itoa64(int64(val.Get())); + case *Uint8Value: + return strconv.Itoa64(int64(val.Get())); + case *Uint16Value: + return strconv.Itoa64(int64(val.Get())); + case *Uint32Value: + return strconv.Itoa64(int64(val.Get())); + case *Uint64Value: + return strconv.Uitoa64(uint64(val.Get())); + case *FloatValue: if strconv.FloatSize == 32 { - return strconv.Ftoa32(float32(val.(FloatValue).Get()), 'g', -1); + return strconv.Ftoa32(float32(val.Get()), 'g', -1); } else { - return strconv.Ftoa64(float64(val.(FloatValue).Get()), 'g', -1); + return strconv.Ftoa64(float64(val.Get()), 'g', -1); } - case Float32Kind: - return strconv.Ftoa32(val.(Float32Value).Get(), 'g', -1); - case Float64Kind: - return strconv.Ftoa64(val.(Float64Value).Get(), 'g', -1); - case StringKind: - return val.(StringValue).Get(); - case BoolKind: - if val.(BoolValue).Get() { + case *Float32Value: + return strconv.Ftoa32(val.Get(), 'g', -1); + case *Float64Value: + return strconv.Ftoa64(val.Get(), 'g', -1); + case *StringValue: + return val.Get(); + case *BoolValue: + if val.Get() { return "true" } else { return "false" } - case PtrKind: - v := val.(PtrValue); - return typeToString(typ, false) + "(" + integer(int64(uintptr(v.Get()))) + ")"; - case ArrayKind: - t := typ.(ArrayType); - v := val.(ArrayValue); - str += typeToString(t, false); + case *PtrValue: + v := val; + str = typ.String() + "("; + if v.IsNil() { + str += "0"; + } else { + str += "&" + valueToString(v.Elem()); + } + str += ")"; + return str; + case ArrayOrSliceValue: + v := val; + str += typ.String(); str += "{"; for i := 0; i < v.Len(); i++ { if i > 0 { @@ -198,23 +83,23 @@ func valueToString(val Value) string { } str += "}"; return str; - case MapKind: - t := typ.(MapType); - v := val.(MapValue); - str = typeToString(t, false); + case *MapValue: + t := typ.(*MapType); + v := val; + str = t.String(); str += "{"; str += ""; str += "}"; return str; - case ChanKind: - str = typeToString(typ, false); + case *ChanValue: + str = typ.String(); return str; - case StructKind: - t := typ.(StructType); - v := val.(StructValue); - str += typeToString(t, false); + case *StructValue: + t := typ.(*StructType); + v := val; + str += t.String(); str += "{"; - for i := 0; i < v.Len(); i++ { + for i, n := 0, v.NumField(); i < n; i++ { if i > 0 { str += ", " } @@ -222,13 +107,13 @@ func valueToString(val Value) string { } str += "}"; return str; - case InterfaceKind: - return "can't print interfaces yet"; - case FuncKind: - v := val.(FuncValue); - return typeToString(typ, false) + "(" + integer(int64(uintptr(v.Get()))) + ")"; + case *InterfaceValue: + return typ.String() + "(" + valueToString(val.Elem()) + ")"; + case *FuncValue: + v := val; + return typ.String() + "(" + strconv.Itoa64(int64(v.Get())) + ")"; default: - panicln("reflect.valueToString: can't print type ", val.Kind()); + panicln("reflect.valueToString: can't print type ", typ.String()); } return "reflect.valueToString: can't happen"; } -- 2.48.1