Example #1
0
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")
	}
}
Example #2
0
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)))
	}
}
Example #3
0
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")
	}
}
Example #4
0
func (a *Server) bind() (conn *net.UDPConn, err error) {
	if !a.NotMulticast && a.iface.Flags&net.FlagMulticast == net.FlagMulticast {
		gaddr, err := a.groupAddr()
		if err != nil {
			return nil, e.Forward(err)
		}
		conn, err = net.ListenMulticastUDP(a.Proto(), a.iface, gaddr)
		if err != nil {
			return nil, e.New(err)
		}
	} else {
		server, err := net.ResolveUDPAddr(a.Proto(), ":"+a.Port)
		if err != nil {
			return nil, e.New(err)
		}
		conn, err = net.ListenUDP(a.Proto(), server)
		if err != nil {
			return nil, e.New(err)
		}
	}
	a.ipver(conn.LocalAddr())
	_, a.Port, err = utilNet.SplitHostPort(conn.LocalAddr().String())
	if err != nil {
		return nil, e.Forward(err)
	}
	return
}
Example #5
0
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)))
	}
}
Example #6
0
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")
	}
}
Example #7
0
// Discover funtion discovers the server and returns the data sent by the server.
func (c *Client) Discover() (*Response, error) {
	if c.Port == "" {
		c.Port = "3456"
	}
	if c.BufSize <= 0 {
		c.BufSize = 1024
	}
	if c.Timeout <= 0 {
		c.Timeout = 2 * time.Minute
	}
	if c.Deadline <= 0 {
		c.Deadline = 10 * time.Second
	}
	if c.Keepalive <= 0 {
		c.Keepalive = 10 * time.Second
	}
	var err error
	if c.Id == "" {
		c.Id, err = rand.Uuid()
		if err != nil {
			return nil, e.Forward(err)
		}
	}
	c.stopKa = make(chan chan struct{})
	c.InitMCast()
	err = c.getInt()
	if err != nil {
		return nil, e.Forward(err)
	}
	resp, err := c.getAddr()
	if err != nil {
		return nil, e.Forward(err)
	}
	return resp, nil
}
Example #8
0
func (cd *CacheDisk) Hits(width, height uint, keys ...interface{}) (h uint32, err error) {
	hash, err := hashKeys(keys...)
	if err != nil {
		return 0, e.Forward(err)
	}

	bufw := encLength(uint64(width))
	bufh := encLength(uint64(height))

	hitshash := []byte(string(hash) + string(bufw) + string(bufh))

	err = cd.db.View(func(tx *bolt.Tx) error {
		var err error
		bhits := tx.Bucket([]byte(hits))
		buf := bhits.Get(hitshash)
		if buf == nil {
			return e.New(ErrImageNotFound)
		}
		h, err = decHits(buf)
		if err != nil {
			return e.Forward(err)
		}
		return nil
	})
	err = e.Forward(err)
	return
}
Example #9
0
func (c *CacheMem) Put(img Image, keys ...interface{}) error {
	c.lck.Lock()
	defer c.lck.Unlock()

	num, err := c.numImages(keys...)
	if err != nil {
		return e.Forward(err)
	}

	if num >= c.maximages {
		err = c.removeLFU(keys...)
		if err != nil {
			return e.Forward(err)
		}
	}

	rect, err := img.Bounds()
	if err != nil {
		return e.Forward(err)
	}

	width := uint(rect.Max.X - rect.Min.X)
	height := uint(rect.Max.Y - rect.Min.Y)

	item, err := newItem(img, width, height, keys...)
	if err != nil {
		return e.Forward(err)
	}

	c.images.ReplaceOrInsert(item)

	return nil
}
Example #10
0
func (c *client) Init() error {
	var err error
	c.session, err = openSession(c.Proto, c.Addr, c.TlsConfig, c.SessionName, c.Auth, c.DialTimeout, c.ConnTimeout)
	if err != nil {
		return e.Forward(err)
	}
	c.clones = &clones{
		Num:    c.NumClones,
		MaxNum: c.MaxNumClones,
	}
	err = c.clones.Init()
	if err != nil {
		return e.Forward(err)
	}
	if c.KeepAlive == 0 {
		return nil
	}
	go func() {
		for {
			time.Sleep(c.KeepAlive)
			err := c.session.Keepalive()
			if err != nil {
				log.ProtoLevel().Tag("gormethods", "client", "keepalive").Printf("Keepalive failed: %v", err)
			}
		}
	}()
	return nil
}
Example #11
0
func (cd *CacheDisk) Put(img Image, keys ...interface{}) error {
	err := cd.db.Update(func(tx *bolt.Tx) error {
		hash, err := hashKeys(keys...)
		if err != nil {
			return e.Forward(err)
		}

		l := lenImg(tx, hash)

		if l >= cd.images {
			err = removeLFU(tx, hash)
			if err != nil {
				return e.Forward(err)
			}
		}

		err = store(tx, img, hash)
		if err != nil {
			return e.Forward(err)
		}

		return nil
	})
	return e.Forward(err)
}
Example #12
0
func (g *Generic) Commit(entry Entry) {
	var err error
	defer func() {
		if err != nil {
			CommitFail(entry, err)
		}
	}()
	if g.r != nil && !g.r.Result(entry) {
		return
	}
	if g.f == nil {
		err = e.New("formater not set")
		return
	}
	err = g.s.Tx(true, func(tx Transaction) error {
		entry.Formatter(g.f)
		err := tx.Put(entry.Date().Format(time.RFC3339Nano), entry)
		if err != nil {
			return e.Forward(err)
		}
		return nil
	})
	if err != nil {
		err = e.Forward(err)
		return
	}
}
Example #13
0
func (p *photo) Transform(crop image.Rectangle, width, height uint, dontenlarge bool, format string, resample resize.InterpolationFunction) (Image, error) {
	img, err := p.Image()
	if err != nil {
		return nil, e.Forward(err)
	}

	imgResized := img
	if !(width == 0 && height == 0) {
		rect := img.Bounds()
		w := uint(rect.Max.X - rect.Min.X)
		h := uint(rect.Max.Y - rect.Min.Y)

		if (width >= w || height >= h) && !dontenlarge {
			imgResized = resize.Resize(width, height, img, resample)
		} else if width < w && height < h {
			imgResized = resize.Resize(width, height, img, resample)
		}
	}

	b := make([]byte, 0, 1024)
	buf := bytes.NewBuffer(b)

	err = jpeg.Encode(buf, imgResized, nil)
	if err != nil {
		return nil, e.Forward(err)
	}

	return &photo{Buf: buf.Bytes()}, nil
}
Example #14
0
File: http.go Project: fcavani/ping
// PingHttp connect a http or https server and try to
// receive something. If the server return a code different
// of 2xx, it will fail. Ignores insecure certificates.
func PingHttp(url *url.URL) error {
	resp, err := httpClient.Get(url.String())
	if e.Contains(err, "connection refused") {
		return e.Push(e.New(err), "get failed: connection refused")
	} else if err != nil {
		return e.Push(e.New(err), "get failed")
	}
	defer resp.Body.Close()
	buf := make([]byte, 4096)
	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
		n, err := resp.Body.Read(buf)
		if err != nil && err != io.EOF {
			return e.Forward(err)
		}
		buf = buf[:n]
		//status.Log(status.Protocol, "PingHttp status code is %v and received it from server: %v", resp.StatusCode, string(buf))
		log.ProtoLevel().Printf("PingHttp status code is %v and received it from server: %v", resp.StatusCode, string(buf))
		return e.New("returned status code %v, expected 2xx", resp.StatusCode)
	}
	_, err = resp.Body.Read(buf)
	if err != nil && err != io.EOF {
		return e.Forward(err)
	}
	return nil
}
Example #15
0
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)
	}
}
Example #16
0
func (c *clones) Request(sess *protoSession, inst string) (connInst, error) {
	c.lck.Lock()
	defer c.lck.Unlock()
	instances, found := c.clones[sess.sess]
	if !found {
		instances = make(map[string]*clone)
		c.clones[sess.sess] = instances
	}
	clonner, found := instances[inst]
	if !found {
		clonner = &clone{
			Num:     c.Num,
			MaxNum:  c.MaxNum,
			Session: sess,
		}
		err := clonner.Init(inst)
		if err != nil {
			return nil, e.Forward(err)
		}
		instances[inst] = clonner
	}
	conn, err := clonner.Request()
	if err != nil {
		return nil, e.Forward(err)
	}
	return conn, nil
}
Example #17
0
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)
	}
}
Example #18
0
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")
	}
}
Example #19
0
func DecInterface(dec *msgpack.Decoder) (interface{}, error) {
	var st status
	err := dec.Decode(&st)
	if err != nil {
		return nil, e.Forward(err)
	}
	switch st {
	case statusNotNil:
		var typename string
		err = dec.Decode(&typename)
		if err != nil {
			return nil, e.Forward(err)
		}
		t, err := types.GetType(typename)
		if err != nil {
			return nil, e.Forward(err)
		}
		ptr := types.Make(reflect.PtrTo(t))
		err = dec.DecodeValue(ptr)
		if err != nil {
			return nil, e.Forward(err)
		}
		return reflect.Indirect(ptr).Interface(), nil
	case statusNil:
		return nil, nil
	}
	panic("not here")
}
Example #20
0
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)
	}
}
Example #21
0
func (etc *etcd) Init() error {
	var err error
	if len(etc.Endpoints) == 0 {
		return e.New("no end points")
	}
	cfg := client.Config{
		Endpoints: etc.Endpoints,
		//Transport: http.DefaultTransport,
	}
	c, err := client.New(cfg)
	if err != nil {
		return e.Forward(err)
	}
	etc.kapi = client.NewKeysAPI(c)

	if etc.SecKeyRing == "" {
		return nil
	}

	kr, err := os.Open(etc.SecKeyRing)
	if err != nil {
		return e.Forward(err)
	}
	defer kr.Close()
	etc.cm, err = config.NewEtcdConfigManager(etc.Endpoints, kr)
	if err != nil {
		return e.Forward(err)
	}

	return nil
}
Example #22
0
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)
	}
}
Example #23
0
func (d *Daemon) exec(cmd string, args ...string) error {
	done := make(chan error, 1)
	c := exec.Command(cmd, args...)
	c.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
	err := c.Start()
	if err != nil {
		return e.Forward(err)
	}
	go func() {
		done <- c.Wait()
	}()
	select {
	case <-time.After(d.ExecTimeout):
		<-done // allow goroutine to exit
		err := c.Process.Kill()
		if err != nil {
			d.status.Log(status.Debug, "Failed to kill command %v for %v.", cmd, d.DaemonName)
			return e.Forward(err)
		}
		d.status.Log(status.Debug, "Command %v exec for %v was killed, timeout.", cmd, d.DaemonName)
	case err := <-done:
		if e.Contains(err, "exit status") {
			msg := "Command %v exec for %v exited with this error: %v"
			d.status.Log(status.Debug, msg, cmd, d.DaemonName, e.Trace(e.Forward(err)))
			return e.Forward(err)
		} else if err != nil {
			return e.Forward(err)
		}
	}
	return nil
}
Example #24
0
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)))
	}
}
Example #25
0
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")
	}
}
Example #26
0
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)
	}
}
Example #27
0
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)))
	}
}
Example #28
0
func startServer() (*core.Server, error) {
	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,
	}
	err := server.Start()
	if err != nil {
		return nil, e.Forward(err)
	}

	err = instances.New("1", "1", reflect.ValueOf(&DummyServer{}), owners)
	if err != nil {
		return nil, e.Forward(err)
	}
	return server, nil
}
Example #29
0
func PrintDb(db *bolt.DB, buckets []string) error {
	err := db.View(func(tx *bolt.Tx) error {
		// err := tx.ForEach(func(name []byte, b *bolt.Bucket) error {
		// 	fmt.Println(string(name))
		// 	return nil
		// })
		for _, bucket := range buckets {
			b := tx.Bucket([]byte(bucket))
			if b == nil {
				log.Printf("Bucket %v not found.", bucket)
				continue
			}
			fmt.Println(bucket, b.Stats().KeyN)
			err := b.ForEach(func(k, v []byte) error {
				fmt.Printf("\t%v -> %v\n", string(k), string(v))
				err := goInside(tx, v, 2)
				if err != nil {
					return e.Forward(err)
				}
				return nil
			})
			if err != nil {
				return e.Forward(err)
			}
		}
		return nil
	})
	if err != nil {
		return e.Forward(err)
	}
	return nil
}
Example #30
0
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)))
	}
}