mirror of
https://github.com/AvengeMedia/DankMaterialShell.git
synced 2026-01-24 13:32:50 -05:00
remove tests from master
This commit is contained in:
bbedward
@@ -1,456 +0,0 @@
|
|||||||
package clipboard
|
|
||||||
|
|
||||||
import (
|
|
||||||
"sync"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/stretchr/testify/assert"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestEncodeDecodeEntry_Roundtrip(t *testing.T) {
|
|
||||||
original := Entry{
|
|
||||||
ID: 12345,
|
|
||||||
Data: []byte("hello world"),
|
|
||||||
MimeType: "text/plain;charset=utf-8",
|
|
||||||
Preview: "hello world",
|
|
||||||
Size: 11,
|
|
||||||
Timestamp: time.Now().Truncate(time.Second),
|
|
||||||
IsImage: false,
|
|
||||||
}
|
|
||||||
|
|
||||||
encoded, err := encodeEntry(original)
|
|
||||||
assert.NoError(t, err)
|
|
||||||
|
|
||||||
decoded, err := decodeEntry(encoded)
|
|
||||||
assert.NoError(t, err)
|
|
||||||
|
|
||||||
assert.Equal(t, original.ID, decoded.ID)
|
|
||||||
assert.Equal(t, original.Data, decoded.Data)
|
|
||||||
assert.Equal(t, original.MimeType, decoded.MimeType)
|
|
||||||
assert.Equal(t, original.Preview, decoded.Preview)
|
|
||||||
assert.Equal(t, original.Size, decoded.Size)
|
|
||||||
assert.Equal(t, original.Timestamp.Unix(), decoded.Timestamp.Unix())
|
|
||||||
assert.Equal(t, original.IsImage, decoded.IsImage)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEncodeDecodeEntry_Image(t *testing.T) {
|
|
||||||
original := Entry{
|
|
||||||
ID: 99999,
|
|
||||||
Data: []byte{0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A},
|
|
||||||
MimeType: "image/png",
|
|
||||||
Preview: "[[ image 8 B png 100x100 ]]",
|
|
||||||
Size: 8,
|
|
||||||
Timestamp: time.Now().Truncate(time.Second),
|
|
||||||
IsImage: true,
|
|
||||||
}
|
|
||||||
|
|
||||||
encoded, err := encodeEntry(original)
|
|
||||||
assert.NoError(t, err)
|
|
||||||
|
|
||||||
decoded, err := decodeEntry(encoded)
|
|
||||||
assert.NoError(t, err)
|
|
||||||
|
|
||||||
assert.Equal(t, original.ID, decoded.ID)
|
|
||||||
assert.Equal(t, original.Data, decoded.Data)
|
|
||||||
assert.True(t, decoded.IsImage)
|
|
||||||
assert.Equal(t, original.Preview, decoded.Preview)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEncodeDecodeEntry_EmptyData(t *testing.T) {
|
|
||||||
original := Entry{
|
|
||||||
ID: 1,
|
|
||||||
Data: []byte{},
|
|
||||||
MimeType: "text/plain",
|
|
||||||
Preview: "",
|
|
||||||
Size: 0,
|
|
||||||
Timestamp: time.Now().Truncate(time.Second),
|
|
||||||
IsImage: false,
|
|
||||||
}
|
|
||||||
|
|
||||||
encoded, err := encodeEntry(original)
|
|
||||||
assert.NoError(t, err)
|
|
||||||
|
|
||||||
decoded, err := decodeEntry(encoded)
|
|
||||||
assert.NoError(t, err)
|
|
||||||
|
|
||||||
assert.Equal(t, original.ID, decoded.ID)
|
|
||||||
assert.Empty(t, decoded.Data)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestEncodeDecodeEntry_LargeData(t *testing.T) {
|
|
||||||
largeData := make([]byte, 100000)
|
|
||||||
for i := range largeData {
|
|
||||||
largeData[i] = byte(i % 256)
|
|
||||||
}
|
|
||||||
|
|
||||||
original := Entry{
|
|
||||||
ID: 777,
|
|
||||||
Data: largeData,
|
|
||||||
MimeType: "application/octet-stream",
|
|
||||||
Preview: "binary data...",
|
|
||||||
Size: len(largeData),
|
|
||||||
Timestamp: time.Now().Truncate(time.Second),
|
|
||||||
IsImage: false,
|
|
||||||
}
|
|
||||||
|
|
||||||
encoded, err := encodeEntry(original)
|
|
||||||
assert.NoError(t, err)
|
|
||||||
|
|
||||||
decoded, err := decodeEntry(encoded)
|
|
||||||
assert.NoError(t, err)
|
|
||||||
|
|
||||||
assert.Equal(t, original.Data, decoded.Data)
|
|
||||||
assert.Equal(t, original.Size, decoded.Size)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStateEqual_BothNil(t *testing.T) {
|
|
||||||
assert.False(t, stateEqual(nil, nil))
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStateEqual_OneNil(t *testing.T) {
|
|
||||||
s := &State{Enabled: true}
|
|
||||||
assert.False(t, stateEqual(s, nil))
|
|
||||||
assert.False(t, stateEqual(nil, s))
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStateEqual_EnabledDiffers(t *testing.T) {
|
|
||||||
a := &State{Enabled: true, History: []Entry{}}
|
|
||||||
b := &State{Enabled: false, History: []Entry{}}
|
|
||||||
assert.False(t, stateEqual(a, b))
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStateEqual_HistoryLengthDiffers(t *testing.T) {
|
|
||||||
a := &State{Enabled: true, History: []Entry{{ID: 1}}}
|
|
||||||
b := &State{Enabled: true, History: []Entry{}}
|
|
||||||
assert.False(t, stateEqual(a, b))
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStateEqual_BothEqual(t *testing.T) {
|
|
||||||
a := &State{Enabled: true, History: []Entry{{ID: 1}, {ID: 2}}}
|
|
||||||
b := &State{Enabled: true, History: []Entry{{ID: 3}, {ID: 4}}}
|
|
||||||
assert.True(t, stateEqual(a, b))
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestManager_ConcurrentSubscriberAccess(t *testing.T) {
|
|
||||||
m := &Manager{
|
|
||||||
subscribers: make(map[string]chan State),
|
|
||||||
dirty: make(chan struct{}, 1),
|
|
||||||
}
|
|
||||||
|
|
||||||
var wg sync.WaitGroup
|
|
||||||
const goroutines = 20
|
|
||||||
|
|
||||||
for i := 0; i < goroutines; i++ {
|
|
||||||
wg.Add(1)
|
|
||||||
go func(id int) {
|
|
||||||
defer wg.Done()
|
|
||||||
subID := string(rune('a' + id))
|
|
||||||
ch := m.Subscribe(subID)
|
|
||||||
assert.NotNil(t, ch)
|
|
||||||
time.Sleep(time.Millisecond)
|
|
||||||
m.Unsubscribe(subID)
|
|
||||||
}(i)
|
|
||||||
}
|
|
||||||
|
|
||||||
wg.Wait()
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestManager_ConcurrentGetState(t *testing.T) {
|
|
||||||
m := &Manager{
|
|
||||||
state: &State{
|
|
||||||
Enabled: true,
|
|
||||||
History: []Entry{{ID: 1}, {ID: 2}},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
var wg sync.WaitGroup
|
|
||||||
const goroutines = 50
|
|
||||||
const iterations = 100
|
|
||||||
|
|
||||||
for i := 0; i < goroutines/2; i++ {
|
|
||||||
wg.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer wg.Done()
|
|
||||||
for j := 0; j < iterations; j++ {
|
|
||||||
s := m.GetState()
|
|
||||||
_ = s.Enabled
|
|
||||||
_ = len(s.History)
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
}
|
|
||||||
|
|
||||||
for i := 0; i < goroutines/2; i++ {
|
|
||||||
wg.Add(1)
|
|
||||||
go func(i int) {
|
|
||||||
defer wg.Done()
|
|
||||||
for j := 0; j < iterations; j++ {
|
|
||||||
m.stateMutex.Lock()
|
|
||||||
m.state = &State{
|
|
||||||
Enabled: j%2 == 0,
|
|
||||||
History: []Entry{{ID: uint64(j)}},
|
|
||||||
}
|
|
||||||
m.stateMutex.Unlock()
|
|
||||||
}
|
|
||||||
}(i)
|
|
||||||
}
|
|
||||||
|
|
||||||
wg.Wait()
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestManager_ConcurrentConfigAccess(t *testing.T) {
|
|
||||||
m := &Manager{
|
|
||||||
config: DefaultConfig(),
|
|
||||||
}
|
|
||||||
|
|
||||||
var wg sync.WaitGroup
|
|
||||||
const goroutines = 30
|
|
||||||
const iterations = 100
|
|
||||||
|
|
||||||
for i := 0; i < goroutines/2; i++ {
|
|
||||||
wg.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer wg.Done()
|
|
||||||
for j := 0; j < iterations; j++ {
|
|
||||||
cfg := m.getConfig()
|
|
||||||
_ = cfg.MaxHistory
|
|
||||||
_ = cfg.MaxEntrySize
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
}
|
|
||||||
|
|
||||||
for i := 0; i < goroutines/2; i++ {
|
|
||||||
wg.Add(1)
|
|
||||||
go func(i int) {
|
|
||||||
defer wg.Done()
|
|
||||||
for j := 0; j < iterations; j++ {
|
|
||||||
m.configMutex.Lock()
|
|
||||||
m.config.MaxHistory = 50 + j
|
|
||||||
m.config.MaxEntrySize = int64(1024 * j)
|
|
||||||
m.configMutex.Unlock()
|
|
||||||
}
|
|
||||||
}(i)
|
|
||||||
}
|
|
||||||
|
|
||||||
wg.Wait()
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestManager_NotifySubscribersNonBlocking(t *testing.T) {
|
|
||||||
m := &Manager{
|
|
||||||
dirty: make(chan struct{}, 1),
|
|
||||||
}
|
|
||||||
|
|
||||||
for i := 0; i < 10; i++ {
|
|
||||||
m.notifySubscribers()
|
|
||||||
}
|
|
||||||
|
|
||||||
assert.Len(t, m.dirty, 1)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestManager_ConcurrentOfferAccess(t *testing.T) {
|
|
||||||
m := &Manager{
|
|
||||||
offerMimeTypes: make(map[any][]string),
|
|
||||||
offerRegistry: make(map[uint32]any),
|
|
||||||
}
|
|
||||||
|
|
||||||
var wg sync.WaitGroup
|
|
||||||
const goroutines = 20
|
|
||||||
const iterations = 50
|
|
||||||
|
|
||||||
for i := 0; i < goroutines; i++ {
|
|
||||||
wg.Add(1)
|
|
||||||
go func(id int) {
|
|
||||||
defer wg.Done()
|
|
||||||
key := uint32(id)
|
|
||||||
|
|
||||||
for j := 0; j < iterations; j++ {
|
|
||||||
m.offerMutex.Lock()
|
|
||||||
m.offerRegistry[key] = struct{}{}
|
|
||||||
m.offerMimeTypes[key] = []string{"text/plain"}
|
|
||||||
m.offerMutex.Unlock()
|
|
||||||
|
|
||||||
m.offerMutex.RLock()
|
|
||||||
_ = m.offerRegistry[key]
|
|
||||||
_ = m.offerMimeTypes[key]
|
|
||||||
m.offerMutex.RUnlock()
|
|
||||||
|
|
||||||
m.offerMutex.Lock()
|
|
||||||
delete(m.offerRegistry, key)
|
|
||||||
delete(m.offerMimeTypes, key)
|
|
||||||
m.offerMutex.Unlock()
|
|
||||||
}
|
|
||||||
}(i)
|
|
||||||
}
|
|
||||||
|
|
||||||
wg.Wait()
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestManager_ConcurrentPersistAccess(t *testing.T) {
|
|
||||||
m := &Manager{
|
|
||||||
persistData: make(map[string][]byte),
|
|
||||||
persistMimeTypes: []string{},
|
|
||||||
}
|
|
||||||
|
|
||||||
var wg sync.WaitGroup
|
|
||||||
const goroutines = 20
|
|
||||||
const iterations = 50
|
|
||||||
|
|
||||||
for i := 0; i < goroutines/2; i++ {
|
|
||||||
wg.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer wg.Done()
|
|
||||||
for j := 0; j < iterations; j++ {
|
|
||||||
m.persistMutex.RLock()
|
|
||||||
_ = m.persistData
|
|
||||||
_ = m.persistMimeTypes
|
|
||||||
m.persistMutex.RUnlock()
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
}
|
|
||||||
|
|
||||||
for i := 0; i < goroutines/2; i++ {
|
|
||||||
wg.Add(1)
|
|
||||||
go func(id int) {
|
|
||||||
defer wg.Done()
|
|
||||||
for j := 0; j < iterations; j++ {
|
|
||||||
m.persistMutex.Lock()
|
|
||||||
m.persistMimeTypes = []string{"text/plain", "text/html"}
|
|
||||||
m.persistData = map[string][]byte{
|
|
||||||
"text/plain": []byte("test"),
|
|
||||||
}
|
|
||||||
m.persistMutex.Unlock()
|
|
||||||
}
|
|
||||||
}(i)
|
|
||||||
}
|
|
||||||
|
|
||||||
wg.Wait()
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestManager_ConcurrentOwnerAccess(t *testing.T) {
|
|
||||||
m := &Manager{}
|
|
||||||
|
|
||||||
var wg sync.WaitGroup
|
|
||||||
const goroutines = 30
|
|
||||||
const iterations = 100
|
|
||||||
|
|
||||||
for i := 0; i < goroutines/2; i++ {
|
|
||||||
wg.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer wg.Done()
|
|
||||||
for j := 0; j < iterations; j++ {
|
|
||||||
m.ownerLock.Lock()
|
|
||||||
_ = m.isOwner
|
|
||||||
m.ownerLock.Unlock()
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
}
|
|
||||||
|
|
||||||
for i := 0; i < goroutines/2; i++ {
|
|
||||||
wg.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer wg.Done()
|
|
||||||
for j := 0; j < iterations; j++ {
|
|
||||||
m.ownerLock.Lock()
|
|
||||||
m.isOwner = j%2 == 0
|
|
||||||
m.ownerLock.Unlock()
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
}
|
|
||||||
|
|
||||||
wg.Wait()
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestItob(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
input uint64
|
|
||||||
expected []byte
|
|
||||||
}{
|
|
||||||
{0, []byte{0, 0, 0, 0, 0, 0, 0, 0}},
|
|
||||||
{1, []byte{0, 0, 0, 0, 0, 0, 0, 1}},
|
|
||||||
{256, []byte{0, 0, 0, 0, 0, 0, 1, 0}},
|
|
||||||
{0xFFFFFFFFFFFFFFFF, []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
result := itob(tt.input)
|
|
||||||
assert.Equal(t, tt.expected, result)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSizeStr(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
input int
|
|
||||||
expected string
|
|
||||||
}{
|
|
||||||
{0, "0 B"},
|
|
||||||
{100, "100 B"},
|
|
||||||
{1024, "1 KiB"},
|
|
||||||
{2048, "2 KiB"},
|
|
||||||
{1048576, "1 MiB"},
|
|
||||||
{5242880, "5 MiB"},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
result := sizeStr(tt.input)
|
|
||||||
assert.Equal(t, tt.expected, result)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSelectMimeType(t *testing.T) {
|
|
||||||
m := &Manager{}
|
|
||||||
|
|
||||||
tests := []struct {
|
|
||||||
mimes []string
|
|
||||||
expected string
|
|
||||||
}{
|
|
||||||
{[]string{"text/plain;charset=utf-8", "text/html"}, "text/plain;charset=utf-8"},
|
|
||||||
{[]string{"text/html", "text/plain"}, "text/plain"},
|
|
||||||
{[]string{"application/json", "image/png"}, "image/png"},
|
|
||||||
{[]string{"application/json", "application/xml"}, ""},
|
|
||||||
{[]string{}, ""},
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, tt := range tests {
|
|
||||||
result := m.selectMimeType(tt.mimes)
|
|
||||||
assert.Equal(t, tt.expected, result)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIsImageMimeType(t *testing.T) {
|
|
||||||
m := &Manager{}
|
|
||||||
|
|
||||||
assert.True(t, m.isImageMimeType("image/png"))
|
|
||||||
assert.True(t, m.isImageMimeType("image/jpeg"))
|
|
||||||
assert.True(t, m.isImageMimeType("image/gif"))
|
|
||||||
assert.False(t, m.isImageMimeType("text/plain"))
|
|
||||||
assert.False(t, m.isImageMimeType("application/json"))
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestTextPreview(t *testing.T) {
|
|
||||||
m := &Manager{}
|
|
||||||
|
|
||||||
short := m.textPreview([]byte("hello world"))
|
|
||||||
assert.Equal(t, "hello world", short)
|
|
||||||
|
|
||||||
withWhitespace := m.textPreview([]byte(" hello world "))
|
|
||||||
assert.Equal(t, "hello world", withWhitespace)
|
|
||||||
|
|
||||||
longText := make([]byte, 200)
|
|
||||||
for i := range longText {
|
|
||||||
longText[i] = 'a'
|
|
||||||
}
|
|
||||||
preview := m.textPreview(longText)
|
|
||||||
assert.True(t, len(preview) > 100)
|
|
||||||
assert.Contains(t, preview, "…")
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestDefaultConfig(t *testing.T) {
|
|
||||||
cfg := DefaultConfig()
|
|
||||||
assert.Equal(t, 100, cfg.MaxHistory)
|
|
||||||
assert.Equal(t, int64(5*1024*1024), cfg.MaxEntrySize)
|
|
||||||
assert.Equal(t, 0, cfg.AutoClearDays)
|
|
||||||
assert.False(t, cfg.ClearAtStartup)
|
|
||||||
assert.False(t, cfg.Disabled)
|
|
||||||
assert.False(t, cfg.DisableHistory)
|
|
||||||
assert.False(t, cfg.DisablePersist)
|
|
||||||
}
|
|
||||||
@@ -1,127 +0,0 @@
|
|||||||
package wlcontext
|
|
||||||
|
|
||||||
import (
|
|
||||||
"sync"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/stretchr/testify/assert"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestSharedContext_ConcurrentPostNonBlocking(t *testing.T) {
|
|
||||||
sc := &SharedContext{
|
|
||||||
cmdQueue: make(chan func(), 256),
|
|
||||||
stopChan: make(chan struct{}),
|
|
||||||
}
|
|
||||||
|
|
||||||
var wg sync.WaitGroup
|
|
||||||
const goroutines = 100
|
|
||||||
const iterations = 50
|
|
||||||
|
|
||||||
for i := 0; i < goroutines; i++ {
|
|
||||||
wg.Add(1)
|
|
||||||
go func(id int) {
|
|
||||||
defer wg.Done()
|
|
||||||
for j := 0; j < iterations; j++ {
|
|
||||||
sc.Post(func() {
|
|
||||||
_ = id + j
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}(i)
|
|
||||||
}
|
|
||||||
|
|
||||||
wg.Wait()
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSharedContext_PostQueueFull(t *testing.T) {
|
|
||||||
sc := &SharedContext{
|
|
||||||
cmdQueue: make(chan func(), 2),
|
|
||||||
stopChan: make(chan struct{}),
|
|
||||||
}
|
|
||||||
|
|
||||||
sc.Post(func() {})
|
|
||||||
sc.Post(func() {})
|
|
||||||
sc.Post(func() {})
|
|
||||||
sc.Post(func() {})
|
|
||||||
|
|
||||||
assert.Len(t, sc.cmdQueue, 2)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSharedContext_StartMultipleTimes(t *testing.T) {
|
|
||||||
sc := &SharedContext{
|
|
||||||
cmdQueue: make(chan func(), 256),
|
|
||||||
stopChan: make(chan struct{}),
|
|
||||||
started: false,
|
|
||||||
}
|
|
||||||
|
|
||||||
var wg sync.WaitGroup
|
|
||||||
const goroutines = 10
|
|
||||||
|
|
||||||
for i := 0; i < goroutines; i++ {
|
|
||||||
wg.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer wg.Done()
|
|
||||||
sc.Start()
|
|
||||||
}()
|
|
||||||
}
|
|
||||||
|
|
||||||
wg.Wait()
|
|
||||||
|
|
||||||
assert.True(t, sc.started)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSharedContext_DrainCmdQueue(t *testing.T) {
|
|
||||||
sc := &SharedContext{
|
|
||||||
cmdQueue: make(chan func(), 256),
|
|
||||||
stopChan: make(chan struct{}),
|
|
||||||
}
|
|
||||||
|
|
||||||
counter := 0
|
|
||||||
for i := 0; i < 10; i++ {
|
|
||||||
sc.cmdQueue <- func() {
|
|
||||||
counter++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
sc.drainCmdQueue()
|
|
||||||
|
|
||||||
assert.Equal(t, 10, counter)
|
|
||||||
assert.Len(t, sc.cmdQueue, 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSharedContext_DrainCmdQueueEmpty(t *testing.T) {
|
|
||||||
sc := &SharedContext{
|
|
||||||
cmdQueue: make(chan func(), 256),
|
|
||||||
stopChan: make(chan struct{}),
|
|
||||||
}
|
|
||||||
|
|
||||||
sc.drainCmdQueue()
|
|
||||||
|
|
||||||
assert.Len(t, sc.cmdQueue, 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSharedContext_ConcurrentDrainAndPost(t *testing.T) {
|
|
||||||
sc := &SharedContext{
|
|
||||||
cmdQueue: make(chan func(), 256),
|
|
||||||
stopChan: make(chan struct{}),
|
|
||||||
}
|
|
||||||
|
|
||||||
var wg sync.WaitGroup
|
|
||||||
|
|
||||||
wg.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer wg.Done()
|
|
||||||
for i := 0; i < 100; i++ {
|
|
||||||
sc.Post(func() {})
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
|
|
||||||
wg.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer wg.Done()
|
|
||||||
for i := 0; i < 50; i++ {
|
|
||||||
sc.drainCmdQueue()
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
|
|
||||||
wg.Wait()
|
|
||||||
}
|
|
||||||
Reference in New Issue
Block a user