13930913017

Committed 18 Mar 2025 06:33PM UTC coverage: 75.939% (+0.08%) from 75.863%

Build Type

github

Committed by maksim.konovalov

Commit Message

pool: Pooler interface supports GetInfo method in TopologyEditor

Pull Request Pull Request #435: pool: Pooler interface supports GetInfo method in TopologyEditor

Run Details

2992 of 3940 relevant lines covered (75.94%)

9863.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

69.33

/smallbuf.go

package tarantool

import (
        "errors"
        "io"
)

type smallBuf struct {
        b []byte
        p int
}

func (s *smallBuf) Read(d []byte) (l int, err error) {
        l = len(s.b) - s.p
        if l == 0 && len(d) > 0 {
                return 0, io.EOF
        }
        if l > len(d) {
                l = len(d)
        }
        copy(d, s.b[s.p:])
        s.p += l
        return l, nil
}

func (s *smallBuf) ReadByte() (b byte, err error) {
        if s.p == len(s.b) {
                return 0, io.EOF
        }
        b = s.b[s.p]
        s.p++
        return b, nil
}

func (s *smallBuf) UnreadByte() error {
        if s.p == 0 {
                return errors.New("could not unread")
        }
        s.p--
        return nil
}

func (s *smallBuf) Len() int {
        return len(s.b) - s.p
}

func (s *smallBuf) Bytes() []byte {
        if len(s.b) > s.p {
                return s.b[s.p:]
        }
        return nil
}

func (s *smallBuf) Offset() int {
        return s.p
}

func (s *smallBuf) Seek(offset int) error {
        if offset < 0 {
                return errors.New("too small offset")
        }
        if offset > len(s.b) {
                return errors.New("too big offset")
        }
        s.p = offset
        return nil
}

type smallWBuf struct {
        b   []byte
        sum uint
        n   uint
}

func (s *smallWBuf) Write(b []byte) (int, error) {
        s.b = append(s.b, b...)
        return len(s.b), nil
}

func (s *smallWBuf) WriteByte(b byte) error {
        s.b = append(s.b, b)
        return nil
}

func (s *smallWBuf) WriteString(ss string) (int, error) {
        s.b = append(s.b, ss...)
        return len(ss), nil
}

func (s smallWBuf) Len() int {
        return len(s.b)
}

func (s smallWBuf) Cap() int {
        return cap(s.b)
}

func (s *smallWBuf) Trunc(n int) {
        s.b = s.b[:n]
}

func (s *smallWBuf) Reset() {
        s.sum = uint(uint64(s.sum)*15/16) + uint(len(s.b))
        if s.n < 16 {
                s.n++
        }
        if cap(s.b) > 1024 && s.sum/s.n < uint(cap(s.b))/4 {
                s.b = make([]byte, 0, s.sum/s.n)
        } else {
                s.b = s.b[:0]
        }
}

1	package tarantool
2
3	import (
4	"errors"
5	"io"
6	)
7
8	type smallBuf struct {
9	b []byte
10	p int
11	}
12
13	func (s *smallBuf) Read(d []byte) (l int, err error) {	359,671✔
14	l = len(s.b) - s.p	359,671✔
15	if l == 0 && len(d) > 0 {	359,671✔
16	return 0, io.EOF	×
17	}	×
18	if l > len(d) {	717,905✔
19	l = len(d)	358,234✔
20	}	358,234✔
21	copy(d, s.b[s.p:])	359,671✔
22	s.p += l	359,671✔
23	return l, nil	359,671✔
24	}
25
26	func (s *smallBuf) ReadByte() (b byte, err error) {	757,823✔
27	if s.p == len(s.b) {	757,823✔
28	return 0, io.EOF	×
29	}	×
30	b = s.b[s.p]	757,823✔
31	s.p++	757,823✔
32	return b, nil	757,823✔
33	}
34
35	func (s *smallBuf) UnreadByte() error {	126,697✔
36	if s.p == 0 {	126,697✔
37	return errors.New("could not unread")	×
38	}	×
39	s.p--	126,697✔
40	return nil	126,697✔
41	}
42
43	func (s *smallBuf) Len() int {	2,517✔
44	return len(s.b) - s.p	2,517✔
45	}	2,517✔
46
47	func (s *smallBuf) Bytes() []byte {	×
48	if len(s.b) > s.p {	×
49	return s.b[s.p:]	×
50	}	×
51	return nil	×
52	}
53
54	func (s *smallBuf) Offset() int {	1,458✔
55	return s.p	1,458✔
56	}	1,458✔
57
58	func (s *smallBuf) Seek(offset int) error {	1,458✔
59	if offset < 0 {	1,458✔
60	return errors.New("too small offset")	×
61	}	×
62	if offset > len(s.b) {	1,458✔
63	return errors.New("too big offset")	×
64	}	×
65	s.p = offset	1,458✔
66	return nil	1,458✔
67	}
68
69	type smallWBuf struct {
70	b []byte
71	sum uint
72	n uint
73	}
74
75	func (s *smallWBuf) Write(b []byte) (int, error) {	7,455✔
76	s.b = append(s.b, b...)	7,455✔
77	return len(s.b), nil	7,455✔
78	}	7,455✔
79
80	func (s *smallWBuf) WriteByte(b byte) error {	17,190✔
81	s.b = append(s.b, b)	17,190✔
82	return nil	17,190✔
83	}	17,190✔
84
85	func (s *smallWBuf) WriteString(ss string) (int, error) {	×
86	s.b = append(s.b, ss...)	×
87	return len(ss), nil	×
88	}	×
89
90	func (s smallWBuf) Len() int {	10,361✔
91	return len(s.b)	10,361✔
92	}	10,361✔
93
94	func (s smallWBuf) Cap() int {	1,816✔
95	return cap(s.b)	1,816✔
96	}	1,816✔
97
98	func (s *smallWBuf) Trunc(n int) {	×
99	s.b = s.b[:n]	×
100	}	×
101
102	func (s *smallWBuf) Reset() {	11,851✔
103	s.sum = uint(uint64(s.sum)*15/16) + uint(len(s.b))	11,851✔
104	if s.n < 16 {	23,702✔
105	s.n++	11,851✔
106	}	11,851✔
107	if cap(s.b) > 1024 && s.sum/s.n < uint(cap(s.b))/4 {	11,851✔
108	s.b = make([]byte, 0, s.sum/s.n)	×
109	} else {	11,851✔
110	s.b = s.b[:0]	11,851✔
111	}	11,851✔
112	}

tarantool / go-tarantool / 13930913017

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous