mirror of
				https://source.quilibrium.com/quilibrium/ceremonyclient.git
				synced 2025-11-04 00:57:26 +00:00 
			
		
		
		
	
		
			
				
	
	
		
			669 lines
		
	
	
		
			12 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
			
		
		
	
	
			669 lines
		
	
	
		
			12 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
package eventbus
 | 
						|
 | 
						|
import (
 | 
						|
	"context"
 | 
						|
	"fmt"
 | 
						|
	"reflect"
 | 
						|
	"sync"
 | 
						|
	"sync/atomic"
 | 
						|
	"testing"
 | 
						|
	"time"
 | 
						|
 | 
						|
	"github.com/libp2p/go-libp2p/core/event"
 | 
						|
 | 
						|
	"github.com/libp2p/go-libp2p-testing/race"
 | 
						|
 | 
						|
	"github.com/stretchr/testify/require"
 | 
						|
)
 | 
						|
 | 
						|
type EventA struct{}
 | 
						|
type EventB int
 | 
						|
 | 
						|
func getN() int {
 | 
						|
	n := 50000
 | 
						|
	if race.WithRace() {
 | 
						|
		n = 1000
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (EventA) String() string {
 | 
						|
	return "Oh, Hello"
 | 
						|
}
 | 
						|
 | 
						|
func TestDefaultSubIsBuffered(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
	s, err := bus.Subscribe(new(EventA))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
	if cap(s.(*sub).ch) == 0 {
 | 
						|
		t.Fatalf("without any options subscribe should be buffered. was %d", cap(s.(*sub).ch))
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func TestEmit(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
	sub, err := bus.Subscribe(new(EventA))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
 | 
						|
	go func() {
 | 
						|
		defer sub.Close()
 | 
						|
		<-sub.Out()
 | 
						|
	}()
 | 
						|
 | 
						|
	em, err := bus.Emitter(new(EventA))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
	defer em.Close()
 | 
						|
 | 
						|
	em.Emit(EventA{})
 | 
						|
}
 | 
						|
 | 
						|
func TestSub(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
	sub, err := bus.Subscribe(new(EventB))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
 | 
						|
	var event EventB
 | 
						|
 | 
						|
	var wait sync.WaitGroup
 | 
						|
	wait.Add(1)
 | 
						|
 | 
						|
	go func() {
 | 
						|
		defer sub.Close()
 | 
						|
		event = (<-sub.Out()).(EventB)
 | 
						|
		wait.Done()
 | 
						|
	}()
 | 
						|
 | 
						|
	em, err := bus.Emitter(new(EventB))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
	defer em.Close()
 | 
						|
 | 
						|
	em.Emit(EventB(7))
 | 
						|
	wait.Wait()
 | 
						|
 | 
						|
	if event != 7 {
 | 
						|
		t.Error("got wrong event")
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func TestGetAllEventTypes(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
	require.Empty(t, bus.GetAllEventTypes())
 | 
						|
 | 
						|
	// the wildcard subscription should be returned.
 | 
						|
	_, err := bus.Subscribe(event.WildcardSubscription)
 | 
						|
	require.NoError(t, err)
 | 
						|
 | 
						|
	_, err = bus.Subscribe(new(EventB))
 | 
						|
	require.NoError(t, err)
 | 
						|
 | 
						|
	evts := bus.GetAllEventTypes()
 | 
						|
	require.Len(t, evts, 1)
 | 
						|
	require.Equal(t, reflect.TypeOf((*EventB)(nil)).Elem(), evts[0])
 | 
						|
 | 
						|
	_, err = bus.Emitter(new(EventA))
 | 
						|
	require.NoError(t, err)
 | 
						|
 | 
						|
	evts = bus.GetAllEventTypes()
 | 
						|
	require.Len(t, evts, 2)
 | 
						|
	require.Contains(t, evts, reflect.TypeOf((*EventB)(nil)).Elem())
 | 
						|
	require.Contains(t, evts, reflect.TypeOf((*EventA)(nil)).Elem())
 | 
						|
}
 | 
						|
 | 
						|
func TestEmitNoSubNoBlock(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
 | 
						|
	em, err := bus.Emitter(new(EventA))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
	defer em.Close()
 | 
						|
 | 
						|
	em.Emit(EventA{})
 | 
						|
}
 | 
						|
 | 
						|
func TestEmitOnClosed(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
 | 
						|
	em, err := bus.Emitter(new(EventA))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
	em.Close()
 | 
						|
	err = em.Emit(EventA{})
 | 
						|
	if err == nil {
 | 
						|
		t.Errorf("expected error")
 | 
						|
	}
 | 
						|
	if err.Error() != "emitter is closed" {
 | 
						|
		t.Error("unexpected message")
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func TestClosingRaces(t *testing.T) {
 | 
						|
	subs := getN()
 | 
						|
	emits := getN()
 | 
						|
 | 
						|
	var wg sync.WaitGroup
 | 
						|
	var lk sync.RWMutex
 | 
						|
	lk.Lock()
 | 
						|
 | 
						|
	wg.Add(subs + emits)
 | 
						|
 | 
						|
	b := NewBus()
 | 
						|
 | 
						|
	for i := 0; i < subs; i++ {
 | 
						|
		go func() {
 | 
						|
			lk.RLock()
 | 
						|
			defer lk.RUnlock()
 | 
						|
 | 
						|
			sub, _ := b.Subscribe(new(EventA))
 | 
						|
			time.Sleep(10 * time.Millisecond)
 | 
						|
			sub.Close()
 | 
						|
 | 
						|
			wg.Done()
 | 
						|
		}()
 | 
						|
	}
 | 
						|
	for i := 0; i < emits; i++ {
 | 
						|
		go func() {
 | 
						|
			lk.RLock()
 | 
						|
			defer lk.RUnlock()
 | 
						|
 | 
						|
			emit, _ := b.Emitter(new(EventA))
 | 
						|
			time.Sleep(10 * time.Millisecond)
 | 
						|
			emit.Close()
 | 
						|
 | 
						|
			wg.Done()
 | 
						|
		}()
 | 
						|
	}
 | 
						|
 | 
						|
	time.Sleep(10 * time.Millisecond)
 | 
						|
	lk.Unlock() // start everything
 | 
						|
 | 
						|
	wg.Wait()
 | 
						|
 | 
						|
	if len(b.(*basicBus).nodes) != 0 {
 | 
						|
		t.Error("expected no nodes")
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func TestSubMany(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
 | 
						|
	var r atomic.Int32
 | 
						|
 | 
						|
	n := getN()
 | 
						|
	var wait sync.WaitGroup
 | 
						|
	var ready sync.WaitGroup
 | 
						|
	wait.Add(n)
 | 
						|
	ready.Add(n)
 | 
						|
 | 
						|
	for i := 0; i < n; i++ {
 | 
						|
		go func() {
 | 
						|
			sub, err := bus.Subscribe(new(EventB))
 | 
						|
			if err != nil {
 | 
						|
				panic(err)
 | 
						|
			}
 | 
						|
			defer sub.Close()
 | 
						|
 | 
						|
			ready.Done()
 | 
						|
			r.Add(int32((<-sub.Out()).(EventB)))
 | 
						|
			wait.Done()
 | 
						|
		}()
 | 
						|
	}
 | 
						|
 | 
						|
	em, err := bus.Emitter(new(EventB))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
	defer em.Close()
 | 
						|
 | 
						|
	ready.Wait()
 | 
						|
 | 
						|
	em.Emit(EventB(7))
 | 
						|
	wait.Wait()
 | 
						|
 | 
						|
	if int(r.Load()) != 7*n {
 | 
						|
		t.Error("got wrong result")
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func TestWildcardSubscription(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
	sub, err := bus.Subscribe(event.WildcardSubscription)
 | 
						|
	require.NoError(t, err)
 | 
						|
	defer sub.Close()
 | 
						|
 | 
						|
	em1, err := bus.Emitter(new(EventA))
 | 
						|
	require.NoError(t, err)
 | 
						|
	defer em1.Close()
 | 
						|
 | 
						|
	em2, err := bus.Emitter(new(EventB))
 | 
						|
	require.NoError(t, err)
 | 
						|
	defer em2.Close()
 | 
						|
 | 
						|
	require.NoError(t, em1.Emit(EventA{}))
 | 
						|
	require.NoError(t, em2.Emit(EventB(1)))
 | 
						|
 | 
						|
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 | 
						|
	defer cancel()
 | 
						|
	var evts []interface{}
 | 
						|
 | 
						|
LOOP:
 | 
						|
	for {
 | 
						|
		select {
 | 
						|
		case evt := <-sub.Out():
 | 
						|
			if evta, ok := evt.(EventA); ok {
 | 
						|
				evts = append(evts, evta)
 | 
						|
			}
 | 
						|
 | 
						|
			if evtb, ok := evt.(EventB); ok {
 | 
						|
				evts = append(evts, evtb)
 | 
						|
			}
 | 
						|
 | 
						|
			if len(evts) == 2 {
 | 
						|
				break LOOP
 | 
						|
			}
 | 
						|
 | 
						|
		case <-ctx.Done():
 | 
						|
			t.Fatalf("did not receive events")
 | 
						|
		}
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func TestManyWildcardSubscriptions(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
	var subs []event.Subscription
 | 
						|
	for i := 0; i < 10; i++ {
 | 
						|
		sub, err := bus.Subscribe(event.WildcardSubscription)
 | 
						|
		require.NoError(t, err)
 | 
						|
		subs = append(subs, sub)
 | 
						|
	}
 | 
						|
 | 
						|
	em1, err := bus.Emitter(new(EventA))
 | 
						|
	require.NoError(t, err)
 | 
						|
	defer em1.Close()
 | 
						|
 | 
						|
	em2, err := bus.Emitter(new(EventB))
 | 
						|
	require.NoError(t, err)
 | 
						|
	defer em2.Close()
 | 
						|
 | 
						|
	require.NoError(t, em1.Emit(EventA{}))
 | 
						|
	require.NoError(t, em2.Emit(EventB(1)))
 | 
						|
 | 
						|
	// all 10 subscriptions received all 2 events.
 | 
						|
	for _, s := range subs {
 | 
						|
		require.Len(t, s.Out(), 2)
 | 
						|
	}
 | 
						|
 | 
						|
	// close the first five subscriptions.
 | 
						|
	for _, s := range subs[:5] {
 | 
						|
		require.NoError(t, s.Close())
 | 
						|
	}
 | 
						|
 | 
						|
	// emit another 2 events.
 | 
						|
	require.NoError(t, em1.Emit(EventA{}))
 | 
						|
	require.NoError(t, em2.Emit(EventB(1)))
 | 
						|
 | 
						|
	// the first five still have 2 events, while the other five have 4 events.
 | 
						|
	for _, s := range subs[:5] {
 | 
						|
		require.Len(t, s.Out(), 2)
 | 
						|
	}
 | 
						|
 | 
						|
	for _, s := range subs[5:] {
 | 
						|
		require.Len(t, s.Out(), 4)
 | 
						|
	}
 | 
						|
 | 
						|
	// close them all, the first five will be closed twice (asserts idempotency).
 | 
						|
	for _, s := range subs {
 | 
						|
		require.NoError(t, s.Close())
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func TestWildcardValidations(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
 | 
						|
	_, err := bus.Subscribe([]interface{}{event.WildcardSubscription, new(EventA), new(EventB)})
 | 
						|
	require.Error(t, err)
 | 
						|
 | 
						|
	_, err = bus.Emitter(event.WildcardSubscription)
 | 
						|
	require.Error(t, err)
 | 
						|
}
 | 
						|
 | 
						|
func TestSubType(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
	sub, err := bus.Subscribe([]interface{}{new(EventA), new(EventB)})
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
 | 
						|
	var event fmt.Stringer
 | 
						|
 | 
						|
	var wait sync.WaitGroup
 | 
						|
	wait.Add(1)
 | 
						|
 | 
						|
	go func() {
 | 
						|
		defer sub.Close()
 | 
						|
		event = (<-sub.Out()).(EventA)
 | 
						|
		wait.Done()
 | 
						|
	}()
 | 
						|
 | 
						|
	em, err := bus.Emitter(new(EventA))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
	defer em.Close()
 | 
						|
 | 
						|
	em.Emit(EventA{})
 | 
						|
	wait.Wait()
 | 
						|
 | 
						|
	if event.String() != "Oh, Hello" {
 | 
						|
		t.Error("didn't get the correct message")
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func TestNonStateful(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
	em, err := bus.Emitter(new(EventB))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
	defer em.Close()
 | 
						|
 | 
						|
	sub1, err := bus.Subscribe(new(EventB), BufSize(1))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
	defer sub1.Close()
 | 
						|
 | 
						|
	select {
 | 
						|
	case <-sub1.Out():
 | 
						|
		t.Fatal("didn't expect to get an event")
 | 
						|
	default:
 | 
						|
	}
 | 
						|
 | 
						|
	em.Emit(EventB(1))
 | 
						|
 | 
						|
	select {
 | 
						|
	case e := <-sub1.Out():
 | 
						|
		if e.(EventB) != 1 {
 | 
						|
			t.Fatal("got wrong event")
 | 
						|
		}
 | 
						|
	default:
 | 
						|
		t.Fatal("expected to get an event")
 | 
						|
	}
 | 
						|
 | 
						|
	sub2, err := bus.Subscribe(new(EventB), BufSize(1))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
	defer sub2.Close()
 | 
						|
 | 
						|
	select {
 | 
						|
	case <-sub2.Out():
 | 
						|
		t.Fatal("didn't expect to get an event")
 | 
						|
	default:
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func TestStateful(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
	em, err := bus.Emitter(new(EventB), Stateful)
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
	defer em.Close()
 | 
						|
 | 
						|
	em.Emit(EventB(2))
 | 
						|
 | 
						|
	sub, err := bus.Subscribe(new(EventB), BufSize(1))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
	defer sub.Close()
 | 
						|
 | 
						|
	if (<-sub.Out()).(EventB) != 2 {
 | 
						|
		t.Fatal("got wrong event")
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func TestCloseBlocking(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
	em, err := bus.Emitter(new(EventB))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
 | 
						|
	sub, err := bus.Subscribe(new(EventB))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
 | 
						|
	go func() {
 | 
						|
		em.Emit(EventB(159))
 | 
						|
	}()
 | 
						|
 | 
						|
	time.Sleep(10 * time.Millisecond) // make sure that emit is blocked
 | 
						|
 | 
						|
	sub.Close() // cancel sub
 | 
						|
}
 | 
						|
 | 
						|
func TestSubFailFully(t *testing.T) {
 | 
						|
	bus := NewBus()
 | 
						|
	em, err := bus.Emitter(new(EventB))
 | 
						|
	if err != nil {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
 | 
						|
	_, err = bus.Subscribe([]interface{}{new(EventB), 5})
 | 
						|
	if err == nil || err.Error() != "subscribe called with non-pointer type" {
 | 
						|
		t.Fatal(err)
 | 
						|
	}
 | 
						|
 | 
						|
	done := make(chan struct{})
 | 
						|
	go func() {
 | 
						|
		defer close(done)
 | 
						|
		em.Emit(EventB(159)) // will hang if sub doesn't fail properly
 | 
						|
	}()
 | 
						|
 | 
						|
	select {
 | 
						|
	case <-done:
 | 
						|
	case <-time.After(5 * time.Second):
 | 
						|
		t.Fatal("timeout")
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func testMany(t testing.TB, subs, emits, msgs int, stateful bool) {
 | 
						|
	if race.WithRace() && subs+emits > 5000 {
 | 
						|
		t.SkipNow()
 | 
						|
	}
 | 
						|
 | 
						|
	bus := NewBus()
 | 
						|
 | 
						|
	var r atomic.Int64
 | 
						|
 | 
						|
	var wait sync.WaitGroup
 | 
						|
	var ready sync.WaitGroup
 | 
						|
	wait.Add(subs + emits)
 | 
						|
	ready.Add(subs)
 | 
						|
 | 
						|
	for i := 0; i < subs; i++ {
 | 
						|
		go func() {
 | 
						|
			sub, err := bus.Subscribe(new(EventB))
 | 
						|
			if err != nil {
 | 
						|
				panic(err)
 | 
						|
			}
 | 
						|
			defer sub.Close()
 | 
						|
 | 
						|
			ready.Done()
 | 
						|
			for i := 0; i < emits*msgs; i++ {
 | 
						|
				e, ok := <-sub.Out()
 | 
						|
				if !ok {
 | 
						|
					panic("wat")
 | 
						|
				}
 | 
						|
				r.Add(int64(e.(EventB)))
 | 
						|
			}
 | 
						|
			wait.Done()
 | 
						|
		}()
 | 
						|
	}
 | 
						|
 | 
						|
	for i := 0; i < emits; i++ {
 | 
						|
		go func() {
 | 
						|
			em, err := bus.Emitter(new(EventB), func(settings interface{}) error {
 | 
						|
				settings.(*emitterSettings).makeStateful = stateful
 | 
						|
				return nil
 | 
						|
			})
 | 
						|
			if err != nil {
 | 
						|
				panic(err)
 | 
						|
			}
 | 
						|
			defer em.Close()
 | 
						|
 | 
						|
			ready.Wait()
 | 
						|
 | 
						|
			for i := 0; i < msgs; i++ {
 | 
						|
				em.Emit(EventB(97))
 | 
						|
			}
 | 
						|
 | 
						|
			wait.Done()
 | 
						|
		}()
 | 
						|
	}
 | 
						|
 | 
						|
	wait.Wait()
 | 
						|
 | 
						|
	if int(r.Load()) != 97*subs*emits*msgs {
 | 
						|
		t.Fatal("got wrong result")
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func TestBothMany(t *testing.T) {
 | 
						|
	testMany(t, 10000, 100, 10, false)
 | 
						|
}
 | 
						|
 | 
						|
type benchCase struct {
 | 
						|
	subs     int
 | 
						|
	emits    int
 | 
						|
	stateful bool
 | 
						|
}
 | 
						|
 | 
						|
func (bc benchCase) name() string {
 | 
						|
	return fmt.Sprintf("subs-%03d/emits-%03d/stateful-%t", bc.subs, bc.emits, bc.stateful)
 | 
						|
}
 | 
						|
 | 
						|
func genTestCases() []benchCase {
 | 
						|
	ret := make([]benchCase, 0, 200)
 | 
						|
	for stateful := 0; stateful < 2; stateful++ {
 | 
						|
		for subs := uint(0); subs <= 8; subs = subs + 4 {
 | 
						|
			for emits := uint(0); emits <= 8; emits = emits + 4 {
 | 
						|
				ret = append(ret, benchCase{1 << subs, 1 << emits, stateful == 1})
 | 
						|
			}
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return ret
 | 
						|
}
 | 
						|
 | 
						|
func BenchmarkEvents(b *testing.B) {
 | 
						|
	for _, bc := range genTestCases() {
 | 
						|
		b.Run(bc.name(), benchMany(bc))
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func benchMany(bc benchCase) func(*testing.B) {
 | 
						|
	return func(b *testing.B) {
 | 
						|
		b.ReportAllocs()
 | 
						|
		subs := bc.subs
 | 
						|
		emits := bc.emits
 | 
						|
		stateful := bc.stateful
 | 
						|
		bus := NewBus()
 | 
						|
		var wait sync.WaitGroup
 | 
						|
		var ready sync.WaitGroup
 | 
						|
		wait.Add(subs + emits)
 | 
						|
		ready.Add(subs + emits)
 | 
						|
 | 
						|
		for i := 0; i < subs; i++ {
 | 
						|
			go func() {
 | 
						|
				sub, err := bus.Subscribe(new(EventB))
 | 
						|
				if err != nil {
 | 
						|
					panic(err)
 | 
						|
				}
 | 
						|
				defer sub.Close()
 | 
						|
 | 
						|
				ready.Done()
 | 
						|
				ready.Wait()
 | 
						|
				for i := 0; i < (b.N/emits)*emits; i++ {
 | 
						|
					_, ok := <-sub.Out()
 | 
						|
					if !ok {
 | 
						|
						panic("wat")
 | 
						|
					}
 | 
						|
				}
 | 
						|
				wait.Done()
 | 
						|
			}()
 | 
						|
		}
 | 
						|
 | 
						|
		for i := 0; i < emits; i++ {
 | 
						|
			go func() {
 | 
						|
				em, err := bus.Emitter(new(EventB), func(settings interface{}) error {
 | 
						|
					settings.(*emitterSettings).makeStateful = stateful
 | 
						|
					return nil
 | 
						|
				})
 | 
						|
				if err != nil {
 | 
						|
					panic(err)
 | 
						|
				}
 | 
						|
				defer em.Close()
 | 
						|
 | 
						|
				ready.Done()
 | 
						|
				ready.Wait()
 | 
						|
 | 
						|
				for i := 0; i < b.N/emits; i++ {
 | 
						|
					em.Emit(EventB(97))
 | 
						|
				}
 | 
						|
 | 
						|
				wait.Done()
 | 
						|
			}()
 | 
						|
		}
 | 
						|
		ready.Wait()
 | 
						|
		b.ResetTimer()
 | 
						|
		wait.Wait()
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
var div = 100
 | 
						|
 | 
						|
func BenchmarkSubscribe(b *testing.B) {
 | 
						|
	b.ReportAllocs()
 | 
						|
	for i := 0; i < b.N/div; i++ {
 | 
						|
		bus := NewBus()
 | 
						|
		for j := 0; j < div; j++ {
 | 
						|
			bus.Subscribe(new(EventA))
 | 
						|
		}
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func BenchmarkEmitter(b *testing.B) {
 | 
						|
	b.ReportAllocs()
 | 
						|
	for i := 0; i < b.N/div; i++ {
 | 
						|
		bus := NewBus()
 | 
						|
		for j := 0; j < div; j++ {
 | 
						|
			bus.Emitter(new(EventA))
 | 
						|
		}
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func BenchmarkSubscribeAndEmitter(b *testing.B) {
 | 
						|
	b.ReportAllocs()
 | 
						|
	for i := 0; i < b.N/div; i++ {
 | 
						|
		bus := NewBus()
 | 
						|
		for j := 0; j < div; j++ {
 | 
						|
			bus.Subscribe(new(EventA))
 | 
						|
			bus.Emitter(new(EventA))
 | 
						|
		}
 | 
						|
	}
 | 
						|
}
 |