go/src/lib/reflect/test.go

// 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.IntKind:
		v.(reflect.IntValue).Put(132);
	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.UintKind:
		v.(reflect.UintValue).Put(132);
	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.FloatKind:
		v.(reflect.FloatValue).Put(3200.0);
	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");
	case reflect.BoolKind:
		v.(reflect.BoolValue).Put(true);
	}
	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;

{
	var ip *int32;
	var i int32 = 1234;
	vip := reflect.NewValue(&ip);
	vi := reflect.NewValue(i);
	vip.(reflect.PtrValue).Sub().(reflect.PtrValue).SetSub(vi);
	if *ip != 1234 {
		panicln("SetSub failure", *ip);
	}
}

	// 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("float80", "float80");
	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("*(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}");
	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 *(args ...)}", "struct{f *(args ...)}");

	// 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", "+3.200000e+01");
	valuedump("float64", "+6.400000e+01");
	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(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, *int(@)}");
	}
	{
		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.IntValue).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.IntValue).Put(123);
		assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "main.AA·test{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}");
	}

	var pt reflect.PtrType;
	var st reflect.StructType;
	var mt reflect.MapType;
	var at reflect.ArrayType;
	var ct reflect.ChanType;
	var name string;
	var typ reflect.Type;
	var tag string;
	var offset int;

	// Type strings
	t = reflect.ParseTypeString("", "int8");
	assert(t.String(), "int8");

	t = reflect.ParseTypeString("", "*int8");
	assert(t.String(), "*int8");
	pt = t.(reflect.PtrType);
	assert(pt.Sub().String(), "int8");

	t = reflect.ParseTypeString("", "*struct {c *chan *int32; d float32}");
	assert(t.String(), "*struct {c *chan *int32; d float32}");
	pt = t.(reflect.PtrType);
	assert(pt.Sub().String(), "struct {c *chan *int32; d float32}");
	st = pt.Sub().(reflect.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 = reflect.ParseTypeString("", "interface {a() *int}");
	assert(t.String(), "interface {a() *int}");

	t = reflect.ParseTypeString("", "*(a int8, b int32)");
	assert(t.String(), "*(a int8, b int32)");

	t = reflect.ParseTypeString("", "*(a int8, b int32) float");
	assert(t.String(), "*(a int8, b int32) float");

	t = reflect.ParseTypeString("", "*(a int8, b int32) (a float, b float)");
	assert(t.String(), "*(a int8, b int32) (a float, b float)");

	t = reflect.ParseTypeString("", "[32]int32");
	assert(t.String(), "[32]int32");
	at = t.(reflect.ArrayType);
	assert(at.Elem().String(), "int32");

	t = reflect.ParseTypeString("", "map[string]*int32");
	assert(t.String(), "map[string]*int32");
	mt = t.(reflect.MapType);
	assert(mt.Key().String(), "string");
	assert(mt.Elem().String(), "*int32");

	t = reflect.ParseTypeString("", "chan<-string");
	assert(t.String(), "chan<-string");
	ct = t.(reflect.ChanType);
	assert(ct.Elem().String(), "string");

	// make sure tag strings are not part of element type
	t = reflect.ParseTypeString("", "struct{d *[]uint32 \"TAG\"}");
	st = t.(reflect.StructType);
	name, typ, tag, offset = st.Field(0);
	assert(typ.String(), "*[]uint32");
}