add reflect to build, clean up test
R=rsc
DELTA=341 (188 added, 151 deleted, 2 changed)
OCL=17678
CL=17750
diff --git a/src/lib/reflect/test.go b/src/lib/reflect/test.go
new file mode 100644
index 0000000..615dda8
--- /dev/null
+++ b/src/lib/reflect/test.go
@@ -0,0 +1,177 @@
+// Copyright 2009 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 main
+
+import (
+ "reflect"
+)
+
+var doprint bool = false
+
+func is_digit(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
+ }
+ 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) {
+ typ := reflect.ParseTypeString("", s);
+ assert(reflect.TypeToString(typ, true), t);
+}
+
+func valuedump(s, t string) {
+ typ := reflect.ParseTypeString("", s);
+ v := reflect.NewInitValue(typ);
+ switch v.Kind() {
+ case reflect.Int8Kind:
+ v.(reflect.Int8Value).Put(8);
+ case reflect.Int16Kind:
+ v.(reflect.Int16Value).Put(16);
+ case reflect.Int32Kind:
+ v.(reflect.Int32Value).Put(32);
+ case reflect.Int64Kind:
+ v.(reflect.Int64Value).Put(64);
+ case reflect.Uint8Kind:
+ v.(reflect.Uint8Value).Put(8);
+ case reflect.Uint16Kind:
+ v.(reflect.Uint16Value).Put(16);
+ case reflect.Uint32Kind:
+ v.(reflect.Uint32Value).Put(32);
+ case reflect.Uint64Kind:
+ v.(reflect.Uint64Value).Put(64);
+ case reflect.Float32Kind:
+ v.(reflect.Float32Value).Put(32.0);
+ case reflect.Float64Kind:
+ v.(reflect.Float64Value).Put(64.0);
+ case reflect.StringKind:
+ v.(reflect.StringValue).Put("stringy cheese");
+ }
+ assert(reflect.ValueToString(v), t);
+}
+
+export type empty interface {}
+
+export type T struct { a int; b float64; c string; d *int }
+
+func main() {
+ var s string;
+ var t reflect.Type;
+
+ typedump("int8", "int8");
+ typedump("int16", "int16");
+ typedump("int32", "int32");
+ typedump("int64", "int64");
+ typedump("uint8", "uint8");
+ typedump("uint16", "uint16");
+ typedump("uint32", "uint32");
+ typedump("uint64", "uint64");
+ typedump("float32", "float32");
+ typedump("float64", "float64");
+ typedump("float80", "float80");
+ typedump("int8", "int8");
+ 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("*(a int8, b int32)", "*(a int8, b int32)");
+ typedump("struct {c *(? *chan *P.integer, ? *int8)}", "struct{c *(? *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}");
+
+ 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", "+3.200000e+01");
+ valuedump("float64", "+6.400000e+01");
+ valuedump("string", "stringy cheese");
+ 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(0)");
+ valuedump("*chan<-string", "*chan<-string(0)");
+ valuedump("struct {c *chan *int32; d float32}", "struct{c *chan*int32; d float32}{*chan*int32(0), +0.000000e+00}");
+ valuedump("*(a int8, b int32)", "*(a int8, b int32)(0)");
+ valuedump("struct {c *(? *chan *P.integer, ? *int8)}", "struct{c *(? *chan*P.integer, ? *int8)}{*(? *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 := reflect.NewValue(tmp);
+ assert(reflect.ValueToString(value), "123");
+ }
+ { var tmp = 123.4;
+ value := reflect.NewValue(tmp);
+ assert(reflect.ValueToString(value), "+1.234000e+02");
+ }
+ { var tmp = "abc";
+ value := reflect.NewValue(tmp);
+ assert(reflect.ValueToString(value), "abc");
+ }
+ {
+ var i int = 7;
+ var tmp = &T{123, 456.0, "hello", &i};
+ value := reflect.NewValue(tmp);
+ assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "main.T{123, +4.560000e+02, hello, *int32(134980)}");
+ }
+ {
+ type C chan *T; // TODO: should not be necessary
+ var tmp = new(C);
+ value := reflect.NewValue(tmp);
+ assert(reflect.ValueToString(value), "*main.C_test(@)");
+ }
+ {
+ type A [10]int;
+ var tmp A = A{1,2,3,4,5,6,7,8,9,10};
+ value := reflect.NewValue(&tmp);
+ assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "main.A_test{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}");
+ value.(reflect.PtrValue).Sub().(reflect.ArrayValue).Elem(4).(reflect.Int32Value).Put(123);
+ assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "main.A_test{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}");
+ }
+ {
+ type AA []int;
+ tmp1 := [10]int{1,2,3,4,5,6,7,8,9,10}; // TODO: should not be necessary to use tmp1
+ var tmp *AA = &tmp1;
+ value := reflect.NewValue(tmp);
+ assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "main.AA_test{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}");
+ value.(reflect.PtrValue).Sub().(reflect.ArrayValue).Elem(4).(reflect.Int32Value).Put(123);
+ assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "main.AA_test{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}");
+ }
+}
