mirror of https://github.com/tidwall/tile38.git
124 lines
2.0 KiB
Go
124 lines
2.0 KiB
Go
package batcher
|
|
|
|
import (
|
|
"errors"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
var errSomeError = errors.New("errSomeError")
|
|
|
|
func returnsError(params []interface{}) error {
|
|
return errSomeError
|
|
}
|
|
|
|
func returnsSuccess(params []interface{}) error {
|
|
return nil
|
|
}
|
|
|
|
func TestBatcherSuccess(t *testing.T) {
|
|
b := New(10*time.Millisecond, returnsSuccess)
|
|
|
|
wg := &sync.WaitGroup{}
|
|
for i := 0; i < 10; i++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
if err := b.Run(nil); err != nil {
|
|
t.Error(err)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
|
|
b = New(0, returnsSuccess)
|
|
for i := 0; i < 10; i++ {
|
|
if err := b.Run(nil); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBatcherError(t *testing.T) {
|
|
b := New(10*time.Millisecond, returnsError)
|
|
|
|
wg := &sync.WaitGroup{}
|
|
for i := 0; i < 10; i++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
if err := b.Run(nil); err != errSomeError {
|
|
t.Error(err)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func TestBatcherPrefilter(t *testing.T) {
|
|
b := New(1*time.Millisecond, returnsSuccess)
|
|
|
|
b.Prefilter(func(param interface{}) error {
|
|
if param == nil {
|
|
return errSomeError
|
|
}
|
|
return nil
|
|
})
|
|
|
|
if err := b.Run(nil); err != errSomeError {
|
|
t.Error(err)
|
|
}
|
|
|
|
if err := b.Run(1); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestBatcherMultipleBatches(t *testing.T) {
|
|
var iters uint32
|
|
|
|
b := New(10*time.Millisecond, func(params []interface{}) error {
|
|
atomic.AddUint32(&iters, 1)
|
|
return nil
|
|
})
|
|
|
|
wg := &sync.WaitGroup{}
|
|
|
|
for group := 0; group < 5; group++ {
|
|
for i := 0; i < 10; i++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
if err := b.Run(nil); err != nil {
|
|
t.Error(err)
|
|
}
|
|
wg.Done()
|
|
}()
|
|
}
|
|
time.Sleep(15 * time.Millisecond)
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
if iters != 5 {
|
|
t.Error("Wrong number of iters:", iters)
|
|
}
|
|
}
|
|
|
|
func ExampleBatcher() {
|
|
b := New(10*time.Millisecond, func(params []interface{}) error {
|
|
// do something with the batch of parameters
|
|
return nil
|
|
})
|
|
|
|
b.Prefilter(func(param interface{}) error {
|
|
// do some sort of sanity check on the parameter, and return an error if it fails
|
|
return nil
|
|
})
|
|
|
|
for i := 0; i < 10; i++ {
|
|
go b.Run(i)
|
|
}
|
|
}
|