func TestFoo(t *testing.T) { err := instances.New("1", "5", reflect.ValueOf(&FooFactory{}), owners) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } ff := &FooFactoryClient{ Net: "tcp", Addrs: server.Address().String(), Auth: id, Session: "1", Instance: "5", PointerRecv: true, } err = ff.Init(true) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } defer ff.CloseClient() foo := ff.Make("test") if err = ff.Error(); err != nil { t.Fatal(e.Trace(e.Forward(err))) } if foo.String() != "foo:test" { t.Fatal("foo returned the wrong string") } }
func BenchmarkBoltDbBuffer(b *testing.B) { name, err := rand.FileName("boltdb", ".db", 10) if err != nil { b.Error(e.Trace(e.Forward(err))) } name = os.TempDir() + "/" + name gob := &Gob{ TypeName: types.Name(&log{}), } bolt, err := NewBoltDb("test", name, 0600, nil, gob, gob) if err != nil { b.Error(e.Trace(e.Forward(err))) } logger := New( NewOutBuffer( NewGeneric(bolt).F(DefFormatter), b.N/2, ), false, ).Domain("test") b.ResetTimer() for i := 0; i < b.N; i++ { logger.Print(msg) b.SetBytes(l) } }
func TestStruct1(t *testing.T) { err := instances.New("1", "2", reflect.ValueOf(&Struct1{}), owners) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } s1 := &Struct1Client{ Net: "tcp", Addrs: server.Address().String(), Auth: id, Session: "1", Instance: "2", PointerRecv: true, } str, err := s1.Func1() if err != nil { t.Fatal(e.Trace(e.Forward(err))) } if str == nil { t.Fatal("nil str") } if *str != "string" { t.Fatal("wrong string", *str) } err = s1.CloseClient() if err != nil { t.Fatal(e.Trace(e.Forward(err))) } }
func TestEditPlainTextCredentials(t *testing.T) { ptc := NewPlainTextCredentials() pt1 := &PlainText{"id", "pass1234"} err := ptc.Add(pt1) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } pt1b := &PlainText{"id", "pass2345"} err = ptc.Edit(pt1b) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } auth, err := ptc.Get("id") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } if !auth.Auth(pt1b) { t.Fatal("auth not equal") } pt2 := &PlainText{"id2", "pass2345"} err = ptc.Edit(pt2) if err != nil && !e.Equal(err, ErrCredNotExist) { t.Fatal(e.Trace(e.Forward(err))) } }
func TestGet(t *testing.T) { inst, err := instances.Get("1", "1") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } if inst.Instance().Type() != reflect.TypeOf(&teststruct{}) { t.Fatal("get fail") } inst, err = instances.Get("1", "3") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } if inst.Instance().Type() != reflect.TypeOf(&teststruct{}) { t.Fatal("get fail") } _, err = instances.Get("1", "1") if err != nil && !e.Equal(err, ErrAuthUserNotAuthorized) { t.Fatal(e.Trace(e.Forward(err))) } _, err = instances.Get("2", "2") if err != nil && !e.Equal(err, ErrSessionNotFound) { t.Fatal(e.Trace(e.Forward(err))) } _, err = instances.Get("1", "2") if err != nil && !e.Equal(err, ErrInstanceNotFound) { t.Fatal(e.Trace(e.Forward(err))) } }
func TestInitClones(t *testing.T) { connPool = &clones{ Num: 1, MaxNum: 5, } err := connPool.Init() if err != nil { t.Fatal(e.Trace(e.Forward(err))) } connPoolErr := &clones{ Num: 0, MaxNum: 5, } err = connPoolErr.Init() if err != nil && !e.Equal(err, "number of clones invalid") { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("nil error") } connPoolErr = &clones{ Num: 10, MaxNum: 5, } err = connPoolErr.Init() if err != nil && !e.Equal(err, "number of streams is greater than max") { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("nil error") } }
func TestAuthSession(t *testing.T) { a := &auth.PlainText{"id3", "pass6969"} err := instances.AuthSession("sess", a) if err != nil && !e.Equal(err, ErrSessionNotFound) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("error is nil") } err = instances.AuthSession("1", a) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = instances.AuthSession("1", &auth.PlainText{"id3", "pass69222269"}) if err != nil && !e.Equal(err, ErrAuthUserNotAuthorized) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("error is nil") } err = instances.AuthSession("1", &auth.PlainText{"id4", "pass69222269"}) if err != nil && !e.Equal(err, ErrAuthUserNotAuthorized) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("error is nil") } }
func TestBigPriority(t *testing.T) { var numQueues uint64 = 1<<64 - 1 q := NewPriority(numQueues, func() (Queue, error) { q := NewSimple(10, 1) return q, nil }) defer q.Stop() q.Process() job := job.NewSimple("name", numQueues-1, func() error { delta, err := rand.Int63n(1000, "go") if err != nil { return e.Forward(err) } delta++ time.Sleep(time.Duration(delta) * time.Millisecond) return nil }) err := q.Add(job) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } job.Returns(&err) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } }
func TestBarrierWriterReaderPartial(t *testing.T) { buf := NewBuffer() defer buf.Close() b, err := rand.Bytes(1e6, "go") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } n, err := buf.Write(b) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } if n != len(b) { t.Fatal("length invalid") } b2 := make([]byte, len(b)) count := 0 l := 100 for count < len(b) { n, err = buf.Read(b2[count : count+l]) if err == io.EOF { break } else if err != nil { t.Fatal(e.Trace(e.Forward(err))) } count += n } if count != len(b) { t.Fatal("length invalid", count, len(b)) } if !bytes.Equal(b, b2) { t.Fatal("not equal") } }
func TestAddPlainTextCredentials(t *testing.T) { ptc := NewPlainTextCredentials() pt1 := &PlainText{"id", "pass1234"} pt1b := &PlainText{"id", "pass1234"} pt2 := &PlainText{"id2", "pass2345"} hash := &Hashed{"a", "b"} err := ptc.Add(pt1) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = ptc.Add(pt2) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = ptc.Add(pt1b) if err != nil && !e.Equal(err, ErrCredExist) { t.Fatal(e.Trace(e.Forward(err))) } err = ptc.Add(hash) if err != nil && !e.Equal(err, ErrNotComp) { t.Fatal(e.Trace(e.Forward(err))) } }
func TestValidate(t *testing.T) { ptc := NewPlainTextCredentials() pt1 := &PlainText{"id", "passpass"} pt2 := &PlainText{"id2", "passpass2"} pt3 := &PlainText{"id3", "passpass2"} pt1b := &PlainText{"id", "passpass2"} err := ptc.Add(pt1) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = ptc.Add(pt2) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = ptc.Add(pt3) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } if err := Validate(ptc, pt1); err != nil { t.Fatal("invalid") } if err := Validate(ptc, pt2); err != nil { t.Fatal("invalid") } if err := Validate(ptc, pt3); err != nil { t.Fatal("invalid") } if err := Validate(ptc, pt1b); err == nil { t.Fatal("invalid") } }
func TestProtoReqInst(t *testing.T) { buf := bytes.NewBuffer([]byte{}) enc := msgpack.NewEncoder(buf) dec := msgpack.NewDecoder(buf) req := &ReqInst{ Inst: "inst", Obj: "obj", Args: []interface{}{"string", int(42)}, } err := enc.Encode(req) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } recv := ReqInst{} err = dec.Decode(&recv) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } if recv.Inst != "inst" || recv.Obj != "obj" || len(recv.Args) != 2 || recv.Args[0].(string) != "string" || recv.Args[1].(int) != 42 { t.Fatal("don't decode") } }
func BenchmarkMongoDbBuffer(b *testing.B) { mongodb, err := NewMongoDb("mongodb://localhost/test", "test", nil, Log, 30*time.Second) if err != nil { b.Error(e.Trace(e.Forward(err))) } err = mongodb.Drop() if err != nil { b.Error(e.Trace(e.Forward(err))) } logger := New( NewOutBuffer( NewGeneric(mongodb).F(DefFormatter), b.N/2, ), false, ).Domain("test") b.ResetTimer() for i := 0; i < b.N; i++ { logger.Print(msg) b.SetBytes(l) } b.StopTimer() err = mongodb.Drop() if err != nil { b.Error(e.Trace(e.Forward(err))) } }
func put(t *testing.T, s Storer, num int) { err := s.Tx(true, func(tx Transaction) error { var err error for i := 0; i < num; i++ { key := strconv.Itoa(i) err = tx.Put(key, &TestStruct{I: i, Key: key}) if err != nil { return err } } err = tx.Put("3a", &TestStruct{I: 3, Key: "3a"}) if err != nil { return err } err = tx.Put("3a", &TestStruct{I: 3, Key: "3a"}) if err != nil { return err } return nil }) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } l, err := s.Len() if err != nil { t.Fatal(e.Trace(e.Forward(err))) } if l != uint(num+1) { t.Fatalf("wrong len %v %v", l, num) } }
func del(t *testing.T, s Storer, num int) { err := s.Tx(true, func(tx Transaction) error { var err error for i := 0; i < num; i++ { key := strconv.Itoa(i) err = tx.Del(key) if err != nil { return err } } err = tx.Del("3a") if err != nil { return err } return nil }) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } l, err := s.Len() if err != nil { t.Fatal(e.Trace(e.Forward(err))) } if l != 0 { t.Fatalf("something remining %v", l) } }
func BenchmarkLogOuterFile(b *testing.B) { name, err := rand.FileName("BenchmarkLogFile", ".log", 10) if err != nil { b.Error(e.Trace(e.Forward(err))) } name = os.TempDir() + "/" + name file, err := os.Create(name) if err != nil { b.Error(e.Trace(e.Forward(err))) } defer os.Remove(name) defer file.Close() backend := NewWriter(file).F(DefFormatter) olog, ok := backend.(OuterLogger) if !ok { return } w := olog.OuterLog(DebugPrio, "tag") defer olog.Close() b.ResetTimer() for i := 0; i < b.N; i++ { n, err := w.Write([]byte(msg + "\n")) if err != nil { b.Error(e.Trace(e.Forward(err))) } if int64(n) != l+1 { b.Error("write failed", n, l) } b.SetBytes(l) } }
func TestDeletePlainTextCredentials(t *testing.T) { ptc := NewPlainTextCredentials() pt1 := &PlainText{"id", "pass1234"} err := ptc.Add(pt1) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } _, err = ptc.Get("id") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = ptc.Delete("id") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = ptc.Delete("id") if err != nil && !e.Equal(err, ErrCredNotExist) { t.Fatal(e.Trace(e.Forward(err))) } _, err = ptc.Get("id") if err != nil && !e.Equal(err, ErrCredNotExist) { t.Fatal(e.Trace(e.Forward(err))) } }
func TestExp(t *testing.T) { client := &TestExportClient{ Net: "tcp", Addrs: serverTest.Address().String(), Auth: &auth.PlainText{"id", "pass1234"}, Session: "1", Instance: "2", Interval: time.Second, } err := client.Init(true) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } ret := client.TestRetval() if ret.Calc() != 42 { t.Fatal("wrong anwser") } // err = client.Destroy() // if err != nil { // t.Fatal(e.Trace(e.Forward(err))) // } err = client.CloseClient() if err != nil { t.Fatal(e.Trace(e.Forward(err))) } }
func BenchmarkLogFileBuffer(b *testing.B) { name, err := rand.FileName("BenchmarkLogFile", ".log", 10) if err != nil { b.Error(e.Trace(e.Forward(err))) } name = os.TempDir() + name file, err := os.Create(name) if err != nil { b.Error(e.Trace(e.Forward(err))) } defer os.Remove(name) defer file.Close() back := NewOutBuffer( NewWriter(file).F(DefFormatter), b.N/2, ) defer back.(*OutBuffer).Close() logger := New(back, false).Domain("test") b.ResetTimer() for i := 0; i < b.N; i++ { logger.Print(msg) b.SetBytes(l) } }
func TestConstructFail(t *testing.T) { err := constructor.New(&struct3{}, func(count int) int { return 42 }) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } _, err = constructor.Construct(types.Name(&struct3{}), 0) if err != nil && !e.Equal(err, ErrInvReturn) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("error is nil") } err = constructor.Delete(types.Name(&struct3{})) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = constructor.New(&struct3{}, func(count int) (int, int) { return 42, 69 }) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } _, err = constructor.Construct(types.Name(&struct3{}), 0) if err != nil && !e.Equal(err, ErrInvReturn) { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("error is nil") } }
// ExecTimeout executes f with arguments args and return a function of type Return. // Return must be called with the pointer to the return values. func (c *Command) ExecTimeout(timeout time.Duration, f interface{}, args ...interface{}) Return { var retvals chan []reflect.Value = make(chan []reflect.Value) val := reflect.ValueOf(f) if val.Kind() != reflect.Func { panic("f is not a function") } t := val.Type() if t.NumIn() != len(args) { panic("invalid number of arguments") } a := make([]reflect.Value, len(args)) for i, arg := range args { a[i] = reflect.ValueOf(arg) if !a[i].Type().AssignableTo(t.In(i)) { panic(fmt.Sprintf("invalid argument type, argument %v must be assignable to %v", a[i].Type(), t.In(i))) } } go func() { var err error if timeout != 0 { err = c.Conn.SetDeadline(time.Now().Add(timeout)) if err != nil { log.Println("SetDeadline failed with error:", e.Trace(e.Forward(err))) } } else { err = c.Conn.SetDeadline(time.Time{}) if err != nil { log.Println("SetDeadline failed with error:", e.Trace(e.Forward(err))) } } values := val.Call(a) if timeout != 0 { err = c.Conn.SetDeadline(time.Time{}) if err != nil { log.Println("SetDeadline failed with error:", e.Trace(e.Forward(err))) } } setError(values, err) retvals <- values }() return func(args ...interface{}) { retvals := <-retvals if len(retvals) != len(args) { panic(fmt.Sprintf("the number of arguments (%v) in Returns must be equal to the number of return values in the function (%v)", len(args), len(retvals))) } for i, retval := range retvals { val := reflect.ValueOf(args[i]) if val.Kind() != reflect.Ptr { panic("Returns arguments must be pointers") } if retval.Type() != val.Elem().Type() { panic("diferent kind") } val.Elem().Set(retval) } } }
func TestStream(t *testing.T) { //ulimit -n 1000 //defer leaktest.Check(t)() var wg sync.WaitGroup t.Log("Num:", numClientTest) wg.Add(numClientTest) s1 := &Struct1Client{ Net: "tcp", Addrs: server.Address().String(), Auth: id, Session: "1", Instance: "2", PointerRecv: true, } err := s1.Init(true) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } var lck sync.Mutex for i := 0; i < numClientTest; i++ { go func(i int) { defer wg.Done() n, err := rand.Int63n(100, "go") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } //println("Waiting...", i) time.Sleep(time.Duration(n) * time.Millisecond) //println("Running...", i) n, err = rand.Int63n(500, "go") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } s1.Wait(time.Duration(n) * time.Millisecond) lck.Lock() err = s1.Error() if err != nil { t.Fatal(e.Trace(e.Forward(err))) } lck.Unlock() //println("End...", i) }(i) } wg.Wait() //println("Close...") err = s1.CloseClient() if err != nil { t.Fatal(e.Trace(e.Forward(err))) } }
func TestFullWriteRead(t *testing.T) { const num = 1000 const maxmax = 1e6 const size = 1e6 bufs := make([][]byte, num) numGoStart := runtime.NumGoroutine() buf := NewBuffer() defer func() { buf.Close() numGoStop := runtime.NumGoroutine() t.Log("NumGoroutine:", numGoStart, numGoStop, numGoStop-numGoStart) }() for i := 0; i < num; i++ { n, err := rand.Int63n(size, "go") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } in, err := rand.Bytes(int(n)+1, "go") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } bufs[i] = in _, err = buf.Write(in) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } } for i := 0; i < num; i++ { n, err := rand.Int63n(maxmax, "go") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } max := int(n) + 1 in := bufs[i] size := len(in) if size > max { size = max } b := make([]byte, len(in)) for count := 0; count < len(in); { end := len(b) if count+size < end { end = count + size } n, err := buf.Read(b[count:end]) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } count += n } if !bytes.Equal(in, b) { t.Fatal("data not equal") } } }
func TestDeleteConstructor(t *testing.T) { err := constructor.Delete(types.Name(&struct1{})) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = constructor.Delete(types.Name(&struct1{})) if err != nil && !e.Equal(err, ErrConstNotFound) { t.Fatal(e.Trace(e.Forward(err))) } }
func TestLdap(t *testing.T) { url := testParse(t, ldapUrl) err := PingLdap(url) if err != nil { t.Log(e.Trace(e.Forward(err))) } err = PingLdapTLS(url) if err != nil { t.Log(e.Trace(e.Forward(err))) } }
func TestProtoWriteReadPartial(t *testing.T) { const num = 10 const maxmax = 1e2 const size = 1e6 bufs := make([][]byte, num) fifo := NewNotAFifo(100) defer fifo.Close() for i := 0; i < num; i++ { n, err := rand.Int63n(size, "go") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } in, err := rand.Bytes(int(n)+1, "go") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } bufs[i] = in err = fifo.Write(in) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } } for i := 0; i < num; i++ { n, err := rand.Int63n(maxmax, "go") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } max := int(n) + 1 in := bufs[i] size := len(in) if size > max { size = max } buf := make([]byte, len(in)) for count := 0; count < len(in); { end := len(buf) if count+size < end { end = count + size } n, err := fifo.Read(buf[count:end]) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } count += n } if !bytes.Equal(in, buf) { t.Fatal("data not equal") } } }
func TestServerIpv4mc(t *testing.T) { in, err := Discover(net.FlagMulticast) if e.Equal(err, ErrNoInt) { t.Log("No multicast capable interface, may be this is travis.cl. Skip the test.") return } else if err != nil { t.Fatal(e.Trace(e.Forward(err))) } server := &Server{} server.Name = "master" server.PrivateKey = MasterKey server.PubKeys = Keys server.Interface = in server.AddrVer = Ipv4 server.Protocol = func(addr *net.UDPAddr, req *Request) (resp *Response, err error) { if string(req.Data) != "request" { return nil, e.New("protocol error") } t.Log(req) return &Response{ Data: []byte("msg"), }, nil } err = server.Do() if err != nil { t.Fatal(e.Trace(e.Forward(err))) } defer server.Close() client := &Client{} client.ServerName = "master" client.ServerKey = &MasterKey.PublicKey client.Name = "slave" client.PrivateKey = SlaveKey client.Interface = in client.AddrVer = Ipv4 client.Port = server.Port client.Request = func(dst *net.UDPAddr) (*Request, error) { return &Request{ Data: []byte("request"), }, nil } resp, err := client.Discover() if err != nil { t.Fatal(e.Trace(e.Forward(err))) } if string(resp.Data) != "msg" { t.Fatal("received wrong message", string(resp.Data)) } t.Log(resp) }
func BenchmarkLoad(b *testing.B) { instances := core.NewInstances() owners := auth.NewPlainTextCredentials() id = &auth.PlainText{Ident: "id", Pass: "******"} owners.Add(id) constructor := core.NewConstructor() server = &core.Server{ Proto: "tcp", Addr: "localhost:0", ConnTimeout: 30 * time.Second, Insts: instances, Cons: constructor, FifoLength: 1, Ttl: 24 * time.Hour, Cleanup: 5 * time.Minute, } server.Start() err := instances.New("1", "3", reflect.ValueOf(&Load{}), owners) if err != nil { b.Error(e.Trace(e.Forward(err))) } l := &LoadClient{ Net: "tcp", Addrs: server.Address().String(), Auth: id, Session: "1", Instance: "3", PointerRecv: true, } err = l.Init(true) if err != nil { b.Error(e.Trace(e.Forward(err))) } in, err := rand.Bytes(1e6, "go") if err != nil { b.Error(e.Trace(e.Forward(err))) } b.ResetTimer() for i := 0; i < b.N; i++ { l.Load(in) b.SetBytes(int64(len(in))) } }
func TestClonesReturnFail(t *testing.T) { conn, err := connPool.Request(p, "0") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } err = connPool.Return("1", "0", conn) if err != nil && !e.Equal(err, ErrSessNotFound) { t.Fatal(e.Trace(e.Forward(err))) } err = connPool.Return("0", "1", conn) if err != nil && !e.Equal(err, ErrInstNotFound) { t.Fatal(e.Trace(e.Forward(err))) } }
func TestInit(t *testing.T) { var err error p, err = openSession("tcp", server.Address().String(), nil, "0", id, time.Second, 0) if err != nil { t.Fatal(e.Trace(e.Forward(err))) } c = &clone{ Num: 1, MaxNum: 5, Session: p, } err = c.Init("0") if err != nil { t.Fatal(e.Trace(e.Forward(err))) } cerr := &clone{ Num: 5, MaxNum: 1, Session: p, } err = cerr.Init("0") if err != nil && !e.Equal(err, "number of initial streams is greater than the maximun") { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("nil error") } cerr = &clone{ Num: 0, MaxNum: 1, Session: p, } err = cerr.Init("0") if err != nil && !e.Equal(err, "number of clones invalid") { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("nil error") } cerr = &clone{ Num: 1, MaxNum: 3, Session: nil, } err = cerr.Init("0") if err != nil && !e.Equal(err, "nil Session") { t.Fatal(e.Trace(e.Forward(err))) } else if err == nil { t.Fatal("nil error") } }