qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-20 06:04:52 -07:00
Code Releases Activity

update reflect supporting functions,

Browse Source 
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
This commit is contained in:
Russ Cox 2009-07-07 11:03:12 -07:00
parent 541e638f9b
commit 64f4e0b197
3 changed files with 367 additions and 505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

553
src/pkg/reflect/all_test.go
View File

@ -12,312 +12,253 @@ import (
"unsafe"; "unsafe";
) )
var doprint bool = false type integer int
type T struct { a int; b float64; c string; d *int }
func is_digit(c uint8) bool { type pair struct {
i interface{};
s string;
}
func isDigit(c uint8) bool {
return '0' <= c && c <= '9' return '0' <= c && c <= '9'
} }
// streq, but '@' in t matches a string of digits func assert(t *testing.T, s, want string) {
func match(s, t string) bool { if s != want {
for i, j := 0, 0; i < len(s) && j < len(t); i, j = i+1, j+1 { t.Errorf("have %#q want %#q", s, want);
if s[i] == t[j] {
continue
}
if is_digit(s[i]) && t[j] == '@' {
for is_digit(s[i+1]) {
i++
}
} else {
return false
}
}
return true;
}
func assert(s, t string) {
if doprint {
println(t)
}
if !match(s, t) {
panicln(s, t)
} }
} }
func typedump(s, t string) { func typestring(i interface{}) string {
typ := ParseTypeString("", s); return Typeof(i).String();
assert(typeToString(typ, true), t);
} }
func valuedump(s, t string) { var typeTests = []pair {
typ := ParseTypeString("", s); pair { struct { x int }{}, "int" },
v := NewZeroValue(typ); pair { struct { x int8 }{}, "int8" },
if v == nil { pair { struct { x int16 }{}, "int16" },
panicln("valuedump", s); pair { struct { x int32 }{}, "int32" },
} pair { struct { x int64 }{}, "int64" },
switch v.Kind() { pair { struct { x uint }{}, "uint" },
case IntKind: pair { struct { x uint8 }{}, "uint8" },
v.(IntValue).Set(132); pair { struct { x uint16 }{}, "uint16" },
case Int8Kind: pair { struct { x uint32 }{}, "uint32" },
v.(Int8Value).Set(8); pair { struct { x uint64 }{}, "uint64" },
case Int16Kind: pair { struct { x float }{}, "float" },
v.(Int16Value).Set(16); pair { struct { x float32 }{}, "float32" },
case Int32Kind: pair { struct { x float64 }{}, "float64" },
v.(Int32Value).Set(32); pair { struct { x int8 }{}, "int8" },
case Int64Kind: pair { struct { x (**int8) }{}, "**int8" },
v.(Int64Value).Set(64); pair { struct { x (**reflect.integer) }{}, "**reflect.integer" },
case UintKind: pair { struct { x ([32]int32) }{}, "[32]int32" },
v.(UintValue).Set(132); pair { struct { x ([]int8) }{}, "[]int8" },
case Uint8Kind: pair { struct { x (map[string]int32) }{}, "map[string] int32" },
v.(Uint8Value).Set(8); pair { struct { x (chan<-string) }{}, "chan<- string" },
case Uint16Kind: pair { struct { x struct {c chan *int32; d float32} }{}, "struct { c chan *int32; d float32 }" },
v.(Uint16Value).Set(16); pair { struct { x (func(a int8, b int32)) }{}, "func(int8, int32)" },
case Uint32Kind: pair { struct { x struct {c func(chan *reflect.integer, *int8)} }{}, "struct { c func(chan *reflect.integer, *int8) }" },
v.(Uint32Value).Set(32); pair { struct { x struct {a int8; b int32} }{}, "struct { a int8; b int32 }" },
case Uint64Kind: pair { struct { x struct {a int8; b int8; b int32} }{}, "struct { a int8; b int8; b int32 }" },
v.(Uint64Value).Set(64); pair { struct { x struct {a int8; b int8; c int8; b int32} }{}, "struct { a int8; b int8; c int8; b int32 }" },
case FloatKind: 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 }" },
v.(FloatValue).Set(3200.0); 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 }" },
case Float32Kind: pair { struct { x struct {a int8 "hi there"; } }{}, `struct { a int8 "hi there" }` },
v.(Float32Value).Set(32.1); pair { struct { x struct {a int8 "hi \x00there\t\n\"\\"; } }{}, `struct { a int8 "hi \x00there\t\n\"\\" }` },
case Float64Kind: pair { struct { x struct {f func(args ...)} }{}, "struct { f func(...) }" },
v.(Float64Value).Set(64.2); 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 () }" },
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 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{<can't iterate on maps>}" },
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 TestAll(tt *testing.T) { // TODO(r): wrap up better func testType(t *testing.T, i int, typ Type, want string) {
var s string; s := typ.String();
var t Type; if s != want {
t.Errorf("#%d: have %#q, want %#q", i, s, want);
}
}
// Types func TestTypes(t *testing.T) {
typedump("missing", "$missing$"); for i, tt := range typeTests {
typedump("int", "int"); testType(t, i, NewValue(tt.i).(*StructValue).Field(0).Type(), tt.s);
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 func TestValue(t *testing.T) {
valuedump("int8", "8"); for i, tt := range valueTests {
valuedump("int16", "16"); v := NewValue(tt.i);
valuedump("int32", "32"); switch v := v.(type) {
valuedump("int64", "64"); case *reflect.IntValue:
valuedump("uint8", "8"); v.Set(132);
valuedump("uint16", "16"); case *reflect.Int8Value:
valuedump("uint32", "32"); v.Set(8);
valuedump("uint64", "64"); case *reflect.Int16Value:
valuedump("float32", "32.1"); v.Set(16);
valuedump("float64", "64.2"); case *reflect.Int32Value:
valuedump("string", "stringy cheese"); v.Set(32);
valuedump("bool", "true"); case *reflect.Int64Value:
valuedump("*int8", "*int8(0)"); v.Set(64);
valuedump("**int8", "**int8(0)"); case *reflect.UintValue:
valuedump("[5]int32", "[5]int32{0, 0, 0, 0, 0}"); v.Set(132);
valuedump("**P.integer", "**P.integer(0)"); case *reflect.Uint8Value:
valuedump("map[string]int32", "map[string]int32{<can't iterate on maps>}"); v.Set(8);
valuedump("chan<-string", "chan<-string"); case *reflect.Uint16Value:
valuedump("struct {c chan *int32; d float32}", "struct{c chan*int32; d float32}{chan*int32, 0}"); v.Set(16);
valuedump("func(a int8, b int32)", "func(a int8, b int32)(0)"); case *reflect.Uint32Value:
valuedump("struct {c func(? chan *P.integer, ? *int8)}", "struct{c func(chan*P.integer, *int8)}{func(chan*P.integer, *int8)(0)}"); v.Set(32);
valuedump("struct {a int8; b int32}", "struct{a int8; b int32}{0, 0}"); case *reflect.Uint64Value:
valuedump("struct {a int8; b int8; b int32}", "struct{a int8; b int8; b int32}{0, 0, 0}"); 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);
}
s := valueToString(v);
if s != tt.s {
t.Errorf("#%d: have %#q, want %#q", i, s, tt.s);
}
}
}
{ var tmp = 123; var _i = 7;
value := NewValue(tmp);
assert(valueToString(value), "123"); 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 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 tmp = 123.4;
value := NewValue(tmp);
assert(valueToString(value), "123.4");
} }
{ }
var tmp = byte(123);
value := NewValue(tmp); func TestArrayElemSet(t *testing.T) {
assert(valueToString(value), "123"); v := NewValue([10]int{1,2,3,4,5,6,7,8,9,10});
assert(typeToString(value.Type(), false), "uint8"); v.(*ArrayValue).Elem(4).(*IntValue).Set(123);
} s := valueToString(v);
{ var tmp = "abc"; const want = "[10]int{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}";
value := NewValue(tmp); if s != want {
assert(valueToString(value), "abc"); t.Errorf("[10]int: have %#q want %#q", s, want);
}
{
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}");
} }
{ 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);
}
}
func TestPtrPointTo(t *testing.T) {
var ip *int32; var ip *int32;
var i int32 = 1234; var i int32 = 1234;
vip := NewValue(&ip); vip := NewValue(&ip);
vi := NewValue(i); vi := NewValue(i);
vip.(PtrValue).Sub().(PtrValue).SetSub(vi); vip.(*PtrValue).Elem().(*PtrValue).PointTo(vi);
if *ip != 1234 { if *ip != 1234 {
panicln("SetSub failure", *ip); t.Errorf("got %d, want 1234", *ip);
}
} }
}
var pt PtrType; func TestAll(t *testing.T) { // TODO(r): wrap up better
var st StructType; testType(t, 1, Typeof((int8)(0)), "int8");
var mt MapType; testType(t, 2, Typeof((*int8)(nil)).(*PtrType).Elem(), "int8");
var at ArrayType;
var ct ChanType;
var name string;
var typ Type;
var tag string;
var offset int;
// Type strings typ := Typeof((*struct{c chan *int32; d float32})(nil));
t = ParseTypeString("", "int8"); testType(t, 3, typ, "*struct { c chan *int32; d float32 }");
assert(t.String(), "int8"); 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");
t = ParseTypeString("", "*int8"); typ = Typeof(([32]int32)(nil));
assert(t.String(), "*int8"); testType(t, 7, typ, "[32]int32");
pt = t.(PtrType); testType(t, 8, typ.(*ArrayType).Elem(), "int32");
assert(pt.Sub().String(), "int8");
t = ParseTypeString("", "*struct {c chan *int32; d float32}"); typ = Typeof((map[string]*int32)(nil));
assert(t.String(), "*struct {c chan *int32; d float32}"); testType(t, 9, typ, "map[string] *int32");
pt = t.(PtrType); mtyp := typ.(*MapType);
assert(pt.Sub().String(), "struct {c chan *int32; d float32}"); testType(t, 10, mtyp.Key(), "string");
st = pt.Sub().(StructType); testType(t, 11, mtyp.Elem(), "*int32");
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}"); typ = Typeof((chan<-string)(nil));
assert(t.String(), "interface {a() *int}"); testType(t, 12, typ, "chan<- string");
testType(t, 13, typ.(*ChanType).Elem(), "string");
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 // make sure tag strings are not part of element type
t = ParseTypeString("", "struct{d []uint32 \"TAG\"}"); typ = Typeof(struct{d []uint32 "TAG"}{}).(*StructType).Field(0).Type;
st = t.(StructType); testType(t, 14, typ, "[]uint32");
name, typ, tag, offset = st.Field(0);
assert(typ.String(), "[]uint32");
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));
}
for i := 0; i < len(a); i++ {
println(a[i]);
}
} }
func TestInterfaceGet(t *testing.T) { func TestInterfaceGet(t *testing.T) {
var inter struct { e interface{ } }; var inter struct { e interface{ } };
inter.e = 123.456; inter.e = 123.456;
v1 := NewValue(&inter); v1 := NewValue(&inter);
v2 := v1.(PtrValue).Sub().(StructValue).Field(0); v2 := v1.(*PtrValue).Elem().(*StructValue).Field(0);
assert(v2.Type().String(), "interface { }"); assert(t, v2.Type().String(), "interface { }");
i2 := v2.(InterfaceValue).Get(); i2 := v2.(*InterfaceValue).Interface();
v3 := NewValue(i2); v3 := NewValue(i2);
assert(v3.Type().String(), "float"); assert(t, v3.Type().String(), "float");
} }
func TestInterfaceValue(t *testing.T) { func TestInterfaceValue(t *testing.T) {
var inter struct { e interface{ } }; var inter struct { e interface{ } };
inter.e = 123.456; inter.e = 123.456;
v1 := NewValue(&inter); v1 := NewValue(&inter);
v2 := v1.(PtrValue).Sub().(StructValue).Field(0); v2 := v1.(*PtrValue).Elem().(*StructValue).Field(0);
assert(v2.Type().String(), "interface { }"); assert(t, v2.Type().String(), "interface { }");
v3 := v2.(InterfaceValue).Value(); v3 := v2.(*InterfaceValue).Elem();
assert(v3.Type().String(), "float"); assert(t, v3.Type().String(), "float");
i3 := v2.Interface(); i3 := v2.Interface();
if f, ok := i3.(float); !ok { if f, ok := i3.(float); !ok {
a, typ, c := unsafe.Reflect(i3); t.Error("v2.Interface() did not return float, got ", Typeof(i3));
t.Error("v2.Interface() did not return float, got ", typ);
} }
} }
@ -326,7 +267,7 @@ func TestFunctionValue(t *testing.T) {
if v.Interface() != v.Interface() { if v.Interface() != v.Interface() {
t.Fatalf("TestFunction != itself"); t.Fatalf("TestFunction != itself");
} }
assert(v.Type().String(), "func()"); assert(t, v.Type().String(), "func()");
} }
func TestCopyArray(t *testing.T) { func TestCopyArray(t *testing.T) {
@ -340,21 +281,25 @@ func TestCopyArray(t *testing.T) {
t.Fatalf("b != c before test"); t.Fatalf("b != c before test");
} }
} }
aa := va.(*PtrValue).Elem().(*SliceValue);
ab := vb.(*PtrValue).Elem().(*SliceValue);
for tocopy := 1; tocopy <= 7; tocopy++ { 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++ { for i := 0; i < tocopy; i++ {
if a[i] != b[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]); tocopy, i, a[i], i, b[i]);
} }
} }
for i := tocopy; i < len(b); i++ { for i := tocopy; i < len(b); i++ {
if b[i] != c[i] { if b[i] != c[i] {
if i < len(a) { 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]); tocopy, i, a[i], i, b[i], i, c[i]);
} else { } 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]); tocopy, i, b[i], i, c[i]);
} }
} else { } else {
@ -369,7 +314,7 @@ func TestBigUnnamedStruct(t *testing.T) {
v := NewValue(b); v := NewValue(b);
b1 := v.Interface().(struct{a,b,c,d int64}); 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 { 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) { func TestTypeof(t *testing.T) {
for i, test := range deepEqualTests { for i, test := range deepEqualTests {
v := NewValue(test.a); v := NewValue(test.a);
if v == nil {
continue;
}
typ := Typeof(test.a); typ := Typeof(test.a);
if typ != v.Type() { if typ != v.Type() {
t.Errorf("Typeof(%v) = %v, but NewValue(%v).Type() = %v", test.a, typ, test.a, 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) { func check2ndField(x interface{}, offs uintptr, t *testing.T) {
s := NewValue(x).(StructValue); s := NewValue(x).(*StructValue);
name, ftype, tag, reflect_offset := s.Type().(StructType).Field(1); f := s.Type().(*StructType).Field(1);
if uintptr(reflect_offset) != offs { if f.Offset != offs {
t.Error("mismatched offsets in structure alignment:", reflect_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); check2ndField(x1, uintptr(unsafe.Pointer(&x1.f)) - uintptr(unsafe.Pointer(&x1)), t);
} }
type Nillable interface { type IsNiller interface {
IsNil() bool IsNil() bool
} }
func Nil(a interface{}, t *testing.T) { func Nil(a interface{}, t *testing.T) {
n := NewValue(a).(Nillable); n := NewValue(a).(*StructValue).Field(0).(IsNiller);
if !n.IsNil() { if !n.IsNil() {
t.Errorf("%v should be nil", a) t.Errorf("%v should be nil", a)
} }
} }
func NotNil(a interface{}, t *testing.T) { func NotNil(a interface{}, t *testing.T) {
n := NewValue(a).(Nillable); n := NewValue(a).(*StructValue).Field(0).(IsNiller);
if n.IsNil() { if n.IsNil() {
t.Errorf("value of type %v should not be nil", NewValue(a).Type().String()) 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) { func TestIsNil(t *testing.T) {
// These do not implement IsNil // These do not implement IsNil
doNotNil := []string{"int", "float32", "struct { a int }"}; doNotNil := []interface{}{ int(0), float32(0), struct{a int}{} };
// These do implement IsNil
doNil := []string{"*int", "interface{}", "map[string]int", "func() bool", "chan int", "[]string"};
for i, ts := range doNotNil { for i, ts := range doNotNil {
ty := ParseTypeString("", ts); ty := Typeof(ts);
v := NewZeroValue(ty); v := MakeZero(ty);
if nilable, ok := v.(Nillable); ok { if nilable, ok := v.(IsNiller); ok {
t.Errorf("%s is nilable; should not be", ts) 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 { for i, ts := range doNil {
ty := ParseTypeString("", ts); ty := Typeof(ts).(*StructType).Field(0).Type;
v := NewZeroValue(ty); v := MakeZero(ty);
if nilable, ok := v.(Nillable); !ok { if nilable, ok := v.(IsNiller); !ok {
t.Errorf("%s %T is not nilable; should be", ts, v) t.Errorf("%s %T is not nilable; should be", ts, v)
} }
} }
// Check the implementations // Check the implementations
var pi *int; var pi struct {x *int}
Nil(pi, t); Nil(pi, t);
pi = new(int); pi.x = new(int);
NotNil(pi, t); NotNil(pi, t);
var si []int; var si struct {x []int}
Nil(si, t); Nil(si, t);
si = make([]int, 10); si.x = make([]int, 10);
NotNil(si, t); 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 ii interface {}; var mi struct {x map[int]int}
Nil(mi, t);
mi.x = make(map[int]int);
NotNil(mi, t);
var ii struct {x interface {}}
Nil(ii, t); Nil(ii, t);
ii = pi; ii.x = 2;
NotNil(ii, t); NotNil(ii, t);
var fi func(t *testing.T); var fi struct {x func(t *testing.T)}
Nil(fi, t); Nil(fi, t);
fi = TestIsNil; fi.x = TestIsNil;
NotNil(fi, t); NotNil(fi, t);
} }
@ -592,7 +557,7 @@ func TestInterfaceExtraction(t *testing.T) {
} }
s.w = os.Stdout; 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{}) { if v != s.w.(interface{}) {
t.Errorf("Interface() on interface: ", v, s.w); t.Errorf("Interface() on interface: ", v, s.w);
} }
@ -612,7 +577,7 @@ func TestInterfaceEditing(t *testing.T) {
// and setting that copy to "bye" should // and setting that copy to "bye" should
// not change the value stored in i. // not change the value stored in i.
v.(StringValue).Set("bye"); v.(*StringValue).Set("bye");
if i.(string) != "hello" { if i.(string) != "hello" {
t.Errorf(`Set("bye") changed i to %s`, i.(string)); 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. // the same should be true of smaller items.
i = 123; i = 123;
v = NewValue(i); v = NewValue(i);
v.(IntValue).Set(234); v.(*IntValue).Set(234);
if i.(int) != 123 { if i.(int) != 123 {
t.Errorf("Set(234) changed i to %d", i.(int)); t.Errorf("Set(234) changed i to %d", i.(int));
} }
@ -628,7 +593,7 @@ func TestInterfaceEditing(t *testing.T) {
func TestNilPtrValueSub(t *testing.T) { func TestNilPtrValueSub(t *testing.T) {
var pi *int; var pi *int;
if pv := NewValue(pi).(PtrValue); pv.Sub() != nil { if pv := NewValue(pi).(*PtrValue); pv.Elem() != nil {
t.Error("NewValue((*int)(nil)).(PtrValue).Sub() != nil"); t.Error("NewValue((*int)(nil)).(*PtrValue).Elem() != nil");
} }
} }

56
src/pkg/reflect/deepequal.go
View File

@ -29,14 +29,14 @@ func deepValueEqual(v1, v2 Value, visited map[uintptr]*visit, depth int) bool {
if v2 == nil { if v2 == nil {
return false return false
} }
if !equalType(v1.Type(), v2.Type()) { if v1.Type() != v2.Type() {
return false; return false;
} }
// if depth > 10 { panic("deepValueEqual") } // for debugging // if depth > 10 { panic("deepValueEqual") } // for debugging
addr1 := uintptr(v1.Addr()); addr1 := v1.Addr();
addr2 := uintptr(v2.Addr()); addr2 := v2.Addr();
if addr1 > addr2 { if addr1 > addr2 {
// Canonicalize order to reduce number of entries in visited. // Canonicalize order to reduce number of entries in visited.
addr1, addr2 = addr2, addr1; addr1, addr2 = addr2, addr1;
@ -60,11 +60,11 @@ func deepValueEqual(v1, v2 Value, visited map[uintptr]*visit, depth int) bool {
// Remember for later. // Remember for later.
visited[h] = &visit{addr1, addr2, typ, seen}; visited[h] = &visit{addr1, addr2, typ, seen};
switch v1.Kind() { switch v := v1.(type) {
case ArrayKind: case *ArrayValue:
arr1 := v1.(ArrayValue); arr1 := v;
arr2 := v2.(ArrayValue); arr2 := v2.(*ArrayValue);
if arr1.IsSlice() != arr2.IsSlice() || arr1.Len() != arr2.Len() { if arr1.Len() != arr2.Len() {
return false; return false;
} }
for i := 0; i < arr1.Len(); i++ { 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; return true;
case InterfaceKind: case *SliceValue:
i1 := v1.(InterfaceValue).Get(); arr1 := v;
i2 := v2.(InterfaceValue).Get(); 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 { if i1 == nil || i2 == nil {
return i1 == i2; return i1 == i2;
} }
return deepValueEqual(NewValue(i1), NewValue(i2), visited, depth+1); return deepValueEqual(NewValue(i1), NewValue(i2), visited, depth+1);
case MapKind: case *MapValue:
// TODO(dnadasi): Implement this fully once MapValue is implemented // TODO(dnadasi): Implement this fully once MapValue is implemented
return v1.Interface() == v2.Interface(); return v1.Interface() == v2.Interface();
case PtrKind: case *PtrValue:
return deepValueEqual(v1.(PtrValue).Sub(), v2.(PtrValue).Sub(), visited, depth+1); return deepValueEqual(v.Elem(), v2.(*PtrValue).Elem(), visited, depth+1);
case StructKind: case *StructValue:
struct1 := v1.(StructValue); struct1 := v;
struct2 := v2.(StructValue); struct2 := v2.(*StructValue);
if struct1.Len() != struct2.Len() { for i, n:= 0, v.NumField(); i < n; i++ {
return false;
}
for i := 0; i < struct1.Len(); i++ {
if !deepValueEqual(struct1.Field(i), struct2.Field(i), visited, depth+1) { if !deepValueEqual(struct1.Field(i), struct2.Field(i), visited, depth+1) {
return false; return false;
} }
@ -112,7 +121,10 @@ func deepValueEqual(v1, v2 Value, visited map[uintptr]*visit, depth int) bool {
func DeepEqual(a1, a2 interface{}) bool { func DeepEqual(a1, a2 interface{}) bool {
v1 := NewValue(a1); v1 := NewValue(a1);
v2 := NewValue(a2); v2 := NewValue(a2);
if !equalType(v1.Type(), v2.Type()) { if v1 == nil {
return v1 == v2;
}
if v1.Type() != v2.Type() {
return false; return false;
} }
return deepValueEqual(v1, v2, make(map[uintptr]*visit), 0); return deepValueEqual(v1, v2, make(map[uintptr]*visit), 0);

251
src/pkg/reflect/tostring.go
View File

@ -14,181 +14,66 @@ import (
"strconv"; "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. // valueToString returns a textual representation of the reflection value val.
// For debugging only. // For debugging only.
func valueToString(val Value) string { func valueToString(val Value) string {
var str string; var str string;
typ := val.Type(); if val == nil {
switch val.Kind() { return "<nil>";
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:
if strconv.FloatSize == 32 {
return strconv.Ftoa32(float32(val.(FloatValue).Get()), 'g', -1);
} else {
return strconv.Ftoa64(float64(val.(FloatValue).Get()), 'g', -1);
} }
case Float32Kind: typ := val.Type();
return strconv.Ftoa32(val.(Float32Value).Get(), 'g', -1); switch val := val.(type) {
case Float64Kind: case *IntValue:
return strconv.Ftoa64(val.(Float64Value).Get(), 'g', -1); return strconv.Uitoa64(uint64(val.Get()));
case StringKind: case *Int8Value:
return val.(StringValue).Get(); return strconv.Itoa64(int64(val.Get()));
case BoolKind: case *Int16Value:
if val.(BoolValue).Get() { 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.Get()), 'g', -1);
} else {
return strconv.Ftoa64(float64(val.Get()), 'g', -1);
}
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" return "true"
} else { } else {
return "false" return "false"
} }
case PtrKind: case *PtrValue:
v := val.(PtrValue); v := val;
return typeToString(typ, false) + "(" + integer(int64(uintptr(v.Get()))) + ")"; str = typ.String() + "(";
case ArrayKind: if v.IsNil() {
t := typ.(ArrayType); str += "0";
v := val.(ArrayValue); } else {
str += typeToString(t, false); str += "&" + valueToString(v.Elem());
}
str += ")";
return str;
case ArrayOrSliceValue:
v := val;
str += typ.String();
str += "{"; str += "{";
for i := 0; i < v.Len(); i++ { for i := 0; i < v.Len(); i++ {
if i > 0 { if i > 0 {
@ -198,23 +83,23 @@ func valueToString(val Value) string {
} }
str += "}"; str += "}";
return str; return str;
case MapKind: case *MapValue:
t := typ.(MapType); t := typ.(*MapType);
v := val.(MapValue); v := val;
str = typeToString(t, false); str = t.String();
str += "{"; str += "{";
str += "<can't iterate on maps>"; str += "<can't iterate on maps>";
str += "}"; str += "}";
return str; return str;
case ChanKind: case *ChanValue:
str = typeToString(typ, false); str = typ.String();
return str; return str;
case StructKind: case *StructValue:
t := typ.(StructType); t := typ.(*StructType);
v := val.(StructValue); v := val;
str += typeToString(t, false); str += t.String();
str += "{"; str += "{";
for i := 0; i < v.Len(); i++ { for i, n := 0, v.NumField(); i < n; i++ {
if i > 0 { if i > 0 {
str += ", " str += ", "
} }
@ -222,13 +107,13 @@ func valueToString(val Value) string {
} }
str += "}"; str += "}";
return str; return str;
case InterfaceKind: case *InterfaceValue:
return "can't print interfaces yet"; return typ.String() + "(" + valueToString(val.Elem()) + ")";
case FuncKind: case *FuncValue:
v := val.(FuncValue); v := val;
return typeToString(typ, false) + "(" + integer(int64(uintptr(v.Get()))) + ")"; return typ.String() + "(" + strconv.Itoa64(int64(v.Get())) + ")";
default: 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"; return "reflect.valueToString: can't happen";
} }