func BenchmarkInsert(b *testing.B) {
for range iter.N(b.N) {
li := newLRUItems()
for range iter.N(10000) {
r := rand.Int63()
t := time.Unix(r/1e9, r%1e9)
li.Insert(ItemInfo{
Accessed: t,
})
}
}
}
func connectSelfLots(n int, t testing.TB) {
defer goroutineLeakCheck(t)()
s, err := NewSocket("udp", "localhost:0")
if err != nil {
t.Fatal(err)
}
go func() {
for range iter.N(n) {
c, err := s.Accept()
if err != nil {
log.Fatal(err)
}
defer c.Close()
}
}()
dialErr := make(chan error)
connCh := make(chan net.Conn)
dialSema := make(chan struct{}, backlog)
for range iter.N(n) {
go func() {
dialSema <- struct{}{}
c, err := s.Dial(s.Addr().String())
<-dialSema
if err != nil {
dialErr <- err
return
}
connCh <- c
}()
}
conns := make([]net.Conn, 0, n)
for range iter.N(n) {
select {
case c := <-connCh:
conns = append(conns, c)
case err := <-dialErr:
t.Fatal(err)
}
}
for _, c := range conns {
if c != nil {
c.Close()
}
}
s.mu.Lock()
for len(s.conns) != 0 {
// log.Print(len(s.conns))
s.event.Wait()
}
s.mu.Unlock()
s.Close()
}
func TestRejectDialBacklogFilled(t *testing.T) {
s, err := NewSocket("udp", "localhost:0")
if err != nil {
t.Fatal(err)
}
errChan := make(chan error, 1)
dial := func() {
_, err := s.Dial(s.Addr().String())
if err != nil {
errChan <- err
}
}
// Fill the backlog.
for range iter.N(backlog + 1) {
go dial()
}
s.mu.Lock()
for len(s.backlog) < backlog {
s.event.Wait()
}
s.mu.Unlock()
select {
case <-errChan:
t.FailNow()
default:
}
// One more connection should cause a dial attempt to get reset.
go dial()
err = <-errChan
if err.Error() != "peer reset" {
t.FailNow()
}
s.Close()
}
func TestAllocs(t *testing.T) {
var x []struct{}
allocs := testing.AllocsPerRun(500, func() {
x = iter.N(1e9)
})
if allocs > 0.1 {
t.Errorf("allocs = %v", allocs)
}
}
func ConvertToSliceOfEmptyInterface(slice interface{}) (ret []interface{}) {
v := reflect.ValueOf(slice)
l := v.Len()
ret = make([]interface{}, 0, l)
for i := range iter.N(v.Len()) {
ret = append(ret, v.Index(i).Interface())
}
return
}
func ExampleN() {
for i := range iter.N(4) {
fmt.Println(i)
}
// Output:
// 0
// 1
// 2
// 3
}
func BenchmarkNewCloseSocket(b *testing.B) {
for range iter.N(b.N) {
s, err := NewSocket("udp", "localhost:0")
if err != nil {
b.Fatal(err)
}
err = s.Close()
if err != nil {
b.Fatal(err)
}
}
}
func testBroadcast(t testing.TB, subs, vals int) {
ps := NewPubSub()
var wg sync.WaitGroup
for range iter.N(subs) {
wg.Add(1)
s := ps.Subscribe()
go func() {
defer wg.Done()
var e int
for i := range s.Values {
assert.Equal(t, e, i.(int))
e++
}
assert.Equal(t, vals, e)
}()
}
for i := range iter.N(vals) {
ps.Publish(i)
}
ps.Close()
wg.Wait()
}
func goroutineLeakCheck(t testing.TB) func() {
if !testing.Verbose() {
return func() {}
}
numStart := runtime.NumGoroutine()
return func() {
var numNow int
for range iter.N(1) {
numNow = runtime.NumGoroutine()
if numNow == numStart {
return
}
time.Sleep(10 * time.Millisecond)
}
// I'd print stacks, or treat this as fatal, but I think
// runtime.NumGoroutine is including system routines for which we are
// not provided the stacks, and are spawned unpredictably.
t.Logf("have %d goroutines, started with %d", numNow, numStart)
}
}
func BenchmarkConnectSelf(b *testing.B) {
for range iter.N(b.N) {
connectSelfLots(2, b)
}
}
func BenchmarkStopCold(b *testing.B) {
tr := NewTimer()
for i := range iter.N(b.N) {
tr.Stop(strconv.FormatInt(int64(i), 10))
}
}
func BenchmarkStopWarm(b *testing.B) {
tr := NewTimer()
for range iter.N(b.N) {
tr.Stop("a")
}
}
func BenchmarkBroadcast(b *testing.B) {
for range iter.N(b.N) {
testBroadcast(b, 10, 1000)
}
}