fix golint issues

master
kevin 4 years ago
parent 338caf9927
commit 94645481b1

@ -37,7 +37,6 @@ type (
BloomFilter struct { BloomFilter struct {
bits uint bits uint
maps uint
bitSet BitSetProvider bitSet BitSetProvider
} }
) )

@ -6,6 +6,8 @@ import (
"io" "io"
) )
const unzipLimit = 100 * 1024 * 1024 // 100MB
func Gzip(bs []byte) []byte { func Gzip(bs []byte) []byte {
var b bytes.Buffer var b bytes.Buffer
@ -24,8 +26,7 @@ func Gunzip(bs []byte) ([]byte, error) {
defer r.Close() defer r.Close()
var c bytes.Buffer var c bytes.Buffer
_, err = io.Copy(&c, r) if _, err = io.Copy(&c, io.LimitReader(r, unzipLimit)); err != nil {
if err != nil {
return nil, err return nil, err
} }

@ -30,8 +30,7 @@ FstHGSkUYFLe+nl1dEKHbD+/Zt95L757J3xGTrwoTc7KCTxbrgn+stn0w52BNjj/
kIE2ko4lbh/v8Fl14AyVR9msfKtKOnhe5FCT72mdtApr+qvzcC3q9hfXwkyQU32p kIE2ko4lbh/v8Fl14AyVR9msfKtKOnhe5FCT72mdtApr+qvzcC3q9hfXwkyQU32p
v7q5UimZ205iKSBmgQIDAQAB v7q5UimZ205iKSBmgQIDAQAB
-----END PUBLIC KEY-----` -----END PUBLIC KEY-----`
testBody = `this is the content` testBody = `this is the content`
encryptedBody = `49e7bc15640e5d927fd3f129b749536d0755baf03a0f35fc914ff1b7b8ce659e5fe3a598442eb908c5995e28bacd3d76e4420bb05b6bfc177040f66c6976f680f7123505d626ab96a9db1151f45c93bc0262db9087b9fb6801715f76f902e644a20029262858f05b0d10540842204346ac1d6d8f29cc5d47dab79af75d922ef2`
) )
func TestCryption(t *testing.T) { func TestCryption(t *testing.T) {

@ -29,7 +29,6 @@ type (
name string name string
lock sync.Mutex lock sync.Mutex
data map[string]interface{} data map[string]interface{}
evicts *list.List
expire time.Duration expire time.Duration
timingWheel *TimingWheel timingWheel *TimingWheel
lruCache lru lruCache lru

@ -88,7 +88,7 @@ func TestRollingWindowReduce(t *testing.T) {
for _, test := range tests { for _, test := range tests {
t.Run(stringx.Rand(), func(t *testing.T) { t.Run(stringx.Rand(), func(t *testing.T) {
r := test.win r := test.win
for x := 0; x < size; x = x + 1 { for x := 0; x < size; x++ {
for i := 0; i <= x; i++ { for i := 0; i <= x; i++ {
r.Add(float64(i)) r.Add(float64(i))
} }

@ -10,8 +10,10 @@ import (
func TestShrinkDeadlineLess(t *testing.T) { func TestShrinkDeadlineLess(t *testing.T) {
deadline := time.Now().Add(time.Second) deadline := time.Now().Add(time.Second)
ctx, _ := context.WithDeadline(context.Background(), deadline) ctx, cancel := context.WithDeadline(context.Background(), deadline)
ctx, _ = ShrinkDeadline(ctx, time.Minute) defer cancel()
ctx, cancel = ShrinkDeadline(ctx, time.Minute)
defer cancel()
dl, ok := ctx.Deadline() dl, ok := ctx.Deadline()
assert.True(t, ok) assert.True(t, ok)
assert.Equal(t, deadline, dl) assert.Equal(t, deadline, dl)
@ -19,8 +21,10 @@ func TestShrinkDeadlineLess(t *testing.T) {
func TestShrinkDeadlineMore(t *testing.T) { func TestShrinkDeadlineMore(t *testing.T) {
deadline := time.Now().Add(time.Minute) deadline := time.Now().Add(time.Minute)
ctx, _ := context.WithDeadline(context.Background(), deadline) ctx, cancel := context.WithDeadline(context.Background(), deadline)
ctx, _ = ShrinkDeadline(ctx, time.Second) defer cancel()
ctx, cancel = ShrinkDeadline(ctx, time.Second)
defer cancel()
dl, ok := ctx.Deadline() dl, ok := ctx.Deadline()
assert.True(t, ok) assert.True(t, ok)
assert.True(t, dl.Before(deadline)) assert.True(t, dl.Before(deadline))

@ -12,7 +12,8 @@ func TestContextCancel(t *testing.T) {
c := context.WithValue(context.Background(), "key", "value") c := context.WithValue(context.Background(), "key", "value")
c1, cancel := context.WithCancel(c) c1, cancel := context.WithCancel(c)
o := ValueOnlyFrom(c1) o := ValueOnlyFrom(c1)
c2, _ := context.WithCancel(o) c2, cancel2 := context.WithCancel(o)
defer cancel2()
contexts := []context.Context{c1, c2} contexts := []context.Context{c1, c2}
for _, c := range contexts { for _, c := range contexts {
@ -35,7 +36,8 @@ func TestContextCancel(t *testing.T) {
} }
func TestContextDeadline(t *testing.T) { func TestContextDeadline(t *testing.T) {
c, _ := context.WithDeadline(context.Background(), time.Now().Add(10*time.Millisecond)) c, cancel := context.WithDeadline(context.Background(), time.Now().Add(10*time.Millisecond))
cancel()
o := ValueOnlyFrom(c) o := ValueOnlyFrom(c)
select { select {
case <-time.After(100 * time.Millisecond): case <-time.After(100 * time.Millisecond):

@ -8,7 +8,7 @@ import (
) )
const ( const (
indexOfKey = iota _ = iota
indexOfId indexOfId
) )

@ -31,6 +31,7 @@ func TestMaxInt(t *testing.T) {
} }
for _, each := range cases { for _, each := range cases {
each := each
t.Run(stringx.Rand(), func(t *testing.T) { t.Run(stringx.Rand(), func(t *testing.T) {
actual := MaxInt(each.a, each.b) actual := MaxInt(each.a, each.b)
assert.Equal(t, each.expect, actual) assert.Equal(t, each.expect, actual)

@ -26,10 +26,6 @@ var started uint32
// Profile represents an active profiling session. // Profile represents an active profiling session.
type Profile struct { type Profile struct {
// path holds the base path where various profiling files are written.
// If blank, the base path will be generated by ioutil.TempDir.
path string
// closers holds cleanup functions that run after each profile // closers holds cleanup functions that run after each profile
closers []func() closers []func()

@ -27,7 +27,7 @@ func newMockedService(multiplier int) *mockedService {
func (s *mockedService) Start() { func (s *mockedService) Start() {
mutex.Lock() mutex.Lock()
number = number * s.multiplier number *= s.multiplier
mutex.Unlock() mutex.Unlock()
done <- struct{}{} done <- struct{}{}
<-s.quit <-s.quit

@ -67,7 +67,3 @@ func TestSignalNoWait(t *testing.T) {
func sleep(millisecond int) { func sleep(millisecond int) {
time.Sleep(time.Duration(millisecond) * time.Millisecond) time.Sleep(time.Duration(millisecond) * time.Millisecond)
} }
func currentTimeMillis() int64 {
return time.Now().UnixNano() / int64(time.Millisecond)
}

@ -95,7 +95,8 @@ func TestExclusiveCallDoDiffDupSuppress(t *testing.T) {
close(broadcast) close(broadcast)
wg.Wait() wg.Wait()
if got := atomic.LoadInt32(&calls); got != 5 { // five letters if got := atomic.LoadInt32(&calls); got != 5 {
// five letters
t.Errorf("number of calls = %d; want 5", got) t.Errorf("number of calls = %d; want 5", got)
} }
} }

@ -16,7 +16,7 @@ func TestRelativeTime(t *testing.T) {
} }
func TestRelativeTime_Time(t *testing.T) { func TestRelativeTime_Time(t *testing.T) {
diff := Time().Sub(time.Now()) diff := time.Until(Time())
if diff > 0 { if diff > 0 {
assert.True(t, diff < time.Second) assert.True(t, diff < time.Second)
} else { } else {

@ -27,12 +27,9 @@ func TestFakeTicker(t *testing.T) {
var count int32 var count int32
go func() { go func() {
for { for range ticker.Chan() {
select { if atomic.AddInt32(&count, 1) == total {
case <-ticker.Chan(): ticker.Done()
if atomic.AddInt32(&count, 1) == total {
ticker.Done()
}
} }
} }
}() }()

@ -17,7 +17,6 @@ const (
clientFlag = "client" clientFlag = "client"
serverFlag = "server" serverFlag = "server"
spanSepRune = '.' spanSepRune = '.'
timeFormat = "2006-01-02 15:04:05.000"
) )
var spanSep = string([]byte{spanSepRune}) var spanSep = string([]byte{spanSepRune})
@ -37,9 +36,7 @@ func newServerSpan(carrier Carrier, serviceName, operationName string) tracespec
return carrier.Get(traceIdKey) return carrier.Get(traceIdKey)
} }
return "" return ""
}, func() string { }, stringx.RandId)
return stringx.RandId()
})
spanId := stringx.TakeWithPriority(func() string { spanId := stringx.TakeWithPriority(func() string {
if carrier != nil { if carrier != nil {
return carrier.Get(spanIdKey) return carrier.Get(spanIdKey)

@ -30,6 +30,7 @@ func TestCompareVersions(t *testing.T) {
} }
for _, each := range cases { for _, each := range cases {
each := each
t.Run(each.ver1, func(t *testing.T) { t.Run(each.ver1, func(t *testing.T) {
actual := CompareVersions(each.ver1, each.operator, each.ver2) actual := CompareVersions(each.ver1, each.operator, each.ver2)
assert.Equal(t, each.out, actual, fmt.Sprintf("%s vs %s", each.ver1, each.ver2)) assert.Equal(t, each.out, actual, fmt.Sprintf("%s vs %s", each.ver1, each.ver2))

@ -128,41 +128,38 @@ func main() {
ticker := time.NewTicker(time.Minute) ticker := time.NewTicker(time.Minute)
defer ticker.Stop() defer ticker.Stop()
for { for range ticker.C {
select { expect, err := loadAll(registry.Client().(*clientv3.Client))
case <-ticker.C: if err != nil {
expect, err := loadAll(registry.Client().(*clientv3.Client)) fmt.Println("[ETCD-test] can't load current keys")
if err != nil { continue
fmt.Println("[ETCD-test] can't load current keys") }
continue
}
check := func() bool { check := func() bool {
var match bool var match bool
barrier.Guard(func() { barrier.Guard(func() {
match = compare(expect, vals) match = compare(expect, vals)
}) })
if match { if match {
logx.Info("match") logx.Info("match")
}
return match
} }
return match
}
if check() {
continue
}
time.AfterFunc(time.Second*5, func() {
if check() { if check() {
continue return
} }
time.AfterFunc(time.Second*5, func() { var builder strings.Builder
if check() { builder.WriteString(fmt.Sprintf("expect:\n%s\n", serializeMap(expect, "\t")))
return barrier.Guard(func() {
} builder.WriteString(fmt.Sprintf("actual:\n%s\n", serializeMap(vals, "\t")))
var builder strings.Builder
builder.WriteString(fmt.Sprintf("expect:\n%s\n", serializeMap(expect, "\t")))
barrier.Guard(func() {
builder.WriteString(fmt.Sprintf("actual:\n%s\n", serializeMap(vals, "\t")))
})
fmt.Println(builder.String())
}) })
} fmt.Println(builder.String())
})
} }
} }

@ -26,10 +26,6 @@ func main() {
} }
writer.Write(user) writer.Write(user)
}, func(pipe <-chan interface{}, writer mr.Writer, cancel func(error)) { }, func(pipe <-chan interface{}, writer mr.Writer, cancel func(error)) {
var users []*User
for p := range pipe {
users = append(users, p.(*User))
}
// missing writer.Write(...), should not panic // missing writer.Write(...), should not panic
}) })
if err != nil { if err != nil {

@ -12,7 +12,11 @@ func main() {
fmt.Println(len(items)) fmt.Println(len(items))
}, executors.WithBulkTasks(10)) }, executors.WithBulkTasks(10))
for { for {
executor.Add(1) if err := executor.Add(1); err != nil {
fmt.Println(err)
return
}
time.Sleep(time.Millisecond * 90) time.Sleep(time.Millisecond * 90)
} }
} }

@ -24,11 +24,8 @@ func main() {
ticker := time.NewTicker(time.Second * 5) ticker := time.NewTicker(time.Second * 5)
defer ticker.Stop() defer ticker.Stop()
for { for range ticker.C {
select { percent := stat.CpuUsage()
case <-ticker.C: fmt.Println("cpu:", percent)
percent := stat.CpuUsage()
fmt.Println("cpu:", percent)
}
} }
} }

@ -45,7 +45,7 @@ func decryptBody(key []byte, r *http.Request) error {
var content []byte var content []byte
var err error var err error
if r.ContentLength > 0 { if r.ContentLength > 0 {
content = make([]byte, r.ContentLength, r.ContentLength) content = make([]byte, r.ContentLength)
_, err = io.ReadFull(r.Body, content) _, err = io.ReadFull(r.Body, content)
} else { } else {
content, err = ioutil.ReadAll(io.LimitReader(r.Body, maxBytes)) content, err = ioutil.ReadAll(io.LimitReader(r.Body, maxBytes))

@ -18,8 +18,6 @@ const (
ServiceTypeRmq ServiceType = "rmq" ServiceTypeRmq ServiceType = "rmq"
ServiceTypeSync ServiceType = "sync" ServiceTypeSync ServiceType = "sync"
envDev = "dev" envDev = "dev"
envPre = "pre"
envPro = "pro"
) )
type ( type (

@ -9,7 +9,7 @@ import (
) )
const ( const (
none = iota _ = iota
primary primary
unique unique
normal normal

@ -53,9 +53,7 @@ func (s String) ToCamel() string {
// camel->snake // camel->snake
func (s String) ToSnake() string { func (s String) ToSnake() string {
list := s.splitBy(func(r rune) bool { list := s.splitBy(unicode.IsUpper, false)
return unicode.IsUpper(r)
}, false)
var target []string var target []string
for _, item := range list { for _, item := range list {
target = append(target, From(item).Lower()) target = append(target, From(item).Lower())

@ -23,6 +23,7 @@ func TestDirectBuilder_Build(t *testing.T) {
} }
for _, test := range tests { for _, test := range tests {
test := test
t.Run(strconv.Itoa(test), func(t *testing.T) { t.Run(strconv.Itoa(test), func(t *testing.T) {
var servers []string var servers []string
for i := 0; i < test; i++ { for i := 0; i < test; i++ {

@ -27,6 +27,7 @@ func TestSubset(t *testing.T) {
} }
for _, test := range tests { for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) { t.Run(test.name, func(t *testing.T) {
var vals []string var vals []string
for i := 0; i < test.set; i++ { for i := 0; i < test.set; i++ {

Loading…
Cancel
Save