func init() {
types.Insert(True{})
types.Insert(False{})
types.Insert(If{})
gob.Register(True{})
gob.Register(False{})
gob.Register(If{})
}
func init() {
gob.Register(&TestExportClient{})
types.Insert(&TestExportClient{})
}
func init() {
gob.Register(&ResultClient{})
types.Insert(&ResultClient{})
}
func init() {
types.Insert(&Error{})
gob.Register(&Error{})
}
func TestRegisterPhoto(t *testing.T) {
types.Insert(&photo{})
}
func init() {
types.Insert(&reqCall{})
}
func init() {
types.Insert(&Tags{})
}
func init() {
gob.Register(&status{})
types.Insert(&status{})
}
func init() {
gob.Register(&log{})
types.Insert(&log{})
}
func init() {
gob.Register(&Disk{})
gob.Register(&Process{})
types.Insert(&Disk{})
types.Insert(&Process{})
}
func init() {
types.Insert(&markedImage{})
}
func init() {
types.Insert(Calculator{})
}
func init() {
types.Insert(foo(""))
}
func init() {
types.Insert(&Time{})
types.Insert(&timehold{})
types.Insert(timehold{})
}
func init() {
gob.Register(&TestChannelClient{})
types.Insert(&TestChannelClient{})
}
func init() {
types.Insert(&ChannelDescriptor{})
}
func init() {
gob.Register(&CacheClient{})
types.Insert(&CacheClient{})
}
func init() {
types.Insert(&TestStruct{})
}
func init() {
types.Insert(&PlainText{})
types.Insert(&Hashed{})
}
func TestReqCall(t *testing.T) {
var nilstruct *reqCall
var err error
str := "string"
//var inil interface{} = nilstruct
var istr interface{} = str
var ipstr interface{} = &str
emptySlice := make([]int, 0)
types.Insert(make([]int, 0))
s := &strct{}
types.Insert(s)
tests := []*reqCall{
{"", nil},
{"oi", []reflect.Value{}},
{"oi", []reflect.Value{reflect.ValueOf(nilstruct)}},
{"oi", []reflect.Value{reflect.ValueOf(err)}},
{"oi", []reflect.Value{reflect.ValueOf(e.New("oi"))}},
{"oi", []reflect.Value{reflect.ValueOf(errors.New("oi"))}},
{"oi", []reflect.Value{reflect.ValueOf(1)}},
{"oi", []reflect.Value{reflect.ValueOf("string")}},
//{"oi", []reflect.Value{reflect.ValueOf(&str)}},
//{"oi", []reflect.Value{reflect.ValueOf(inil)}},
{"oi", []reflect.Value{reflect.ValueOf(istr)}},
{"oi", []reflect.Value{reflect.ValueOf(ipstr)}},
{"oi", []reflect.Value{reflect.ValueOf(s)}},
{"oi", []reflect.Value{reflect.ValueOf(emptySlice)}},
}
for i, test := range tests {
buf := bytes.NewBuffer([]byte{})
enc := msgpack.NewEncoder(buf)
dec := msgpack.NewDecoder(buf)
err := enc.Encode(test)
if err != nil {
t.Fatal(i, e.Trace(e.Forward(err)))
}
var req reqCall
err = dec.Decode(&req)
if err != nil {
t.Fatal(i, e.Trace(e.Forward(err)))
}
if req.Method != test.Method {
t.Fatal("method not equal")
}
if len(req.Args) != len(test.Args) {
t.Fatal("num of args not equal")
}
for ii, arg := range req.Args {
if zero.IsZero(arg) != zero.IsZero(test.Args[ii]) {
t.Fatal("arg differ", i, ii, zero.IsZero(arg), zero.IsZero(test.Args[ii]))
}
if zero.IsZero(arg) {
continue
}
if arg.IsValid() != test.Args[ii].IsValid() {
t.Fatal("valid differ")
}
if !arg.IsValid() {
continue
}
if test.Args[ii].Kind() == reflect.Interface || test.Args[ii].Kind() == reflect.Map || test.Args[ii].Kind() == reflect.Ptr || test.Args[ii].Kind() == reflect.Slice {
if arg.IsNil() != test.Args[ii].IsNil() {
t.Fatal("arg differ", i, arg.IsNil(), test.Args[ii].IsNil())
}
if arg.IsNil() {
continue
}
}
if _, ok := arg.Interface().(*e.Error); !ok && !reflect.DeepEqual(arg.Interface(), test.Args[ii].Interface()) {
t.Fatalf("Fail to encode and decode %v %#v %#v", i, arg.Interface(), test.Args[ii].Interface())
}
}
}
}
func init() {
types.Insert(Calc{})
}