mirror of
https://github.com/d0zingcat/gocryptotrader.git
synced 2026-05-19 23:16:48 +00:00
242b02c382
* Removes lock unlock timer and instead sets unlocks between getting a nonce and sending a payload. Increases dispatch channel buffer to deal with len(enabledCurrencies) > ~100 * Adds additional comments to help explain the situation * Fixes bug that could unlock mutex too early * Fixes LIES where Gemini gets a nonce and then proceeds to declare it doesn't get a nonce causing an unrecoverable lock * Fun new concept! The creation of a tested timed mutex. Unlocking an unlocked mutex cannot occur and response can be checked to verify whether the mutex was unlocked from timeout or command. * Adds new cmd parameter "dispatchjobbuffer" * Expands comments and renames benchmark. Makes `Timer` property private * Happy little linters * Renames jobBuffer and all related instances to jobs limit * Tiny error message update * Grammatical fix and setting dispatch.Start to use defaults
87 lines
2.1 KiB
Go
87 lines
2.1 KiB
Go
package timedmutex
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func BenchmarkTimedMutexTime(b *testing.B) {
|
|
tm := NewTimedMutex(20 * time.Millisecond)
|
|
for i := 0; i < b.N; i++ {
|
|
tm.LockForDuration()
|
|
}
|
|
}
|
|
|
|
func TestConsistencyOfPanicFreeUnlock(t *testing.T) {
|
|
t.Parallel()
|
|
duration := 20 * time.Millisecond
|
|
tm := NewTimedMutex(duration)
|
|
for i := 1; i <= 50; i++ {
|
|
testUnlockTime := time.Duration(i) * time.Millisecond
|
|
tm.LockForDuration()
|
|
time.Sleep(testUnlockTime)
|
|
tm.UnlockIfLocked()
|
|
}
|
|
}
|
|
|
|
func TestUnlockAfterTimeout(t *testing.T) {
|
|
t.Parallel()
|
|
tm := NewTimedMutex(time.Second)
|
|
tm.LockForDuration()
|
|
time.Sleep(2 * time.Second)
|
|
wasUnlocked := tm.UnlockIfLocked()
|
|
if wasUnlocked {
|
|
t.Error("Mutex should have been unlocked by timeout, not command")
|
|
}
|
|
}
|
|
|
|
func TestUnlockBeforeTimeout(t *testing.T) {
|
|
t.Parallel()
|
|
tm := NewTimedMutex(2 * time.Second)
|
|
tm.LockForDuration()
|
|
time.Sleep(time.Second)
|
|
wasUnlocked := tm.UnlockIfLocked()
|
|
if !wasUnlocked {
|
|
t.Error("Mutex should have been unlocked by command, not timeout")
|
|
}
|
|
}
|
|
|
|
// TestUnlockAtSameTimeAsTimeout this test ensures
|
|
// that even if the timeout and the command occur at
|
|
// the same time, no panics occur. The result of the
|
|
// 'who' unlocking this doesn't matter, so long as
|
|
// the unlock occurs without this test panicking
|
|
func TestUnlockAtSameTimeAsTimeout(t *testing.T) {
|
|
t.Parallel()
|
|
duration := time.Second
|
|
tm := NewTimedMutex(duration)
|
|
tm.LockForDuration()
|
|
time.Sleep(duration)
|
|
tm.UnlockIfLocked()
|
|
}
|
|
|
|
func TestMultipleUnlocks(t *testing.T) {
|
|
t.Parallel()
|
|
tm := NewTimedMutex(10 * time.Second)
|
|
tm.LockForDuration()
|
|
wasUnlocked := tm.UnlockIfLocked()
|
|
if !wasUnlocked {
|
|
t.Error("Mutex should have been unlocked by command, not timeout")
|
|
}
|
|
wasUnlocked = tm.UnlockIfLocked()
|
|
if wasUnlocked {
|
|
t.Error("Mutex should have been already unlocked by command")
|
|
}
|
|
wasUnlocked = tm.UnlockIfLocked()
|
|
if wasUnlocked {
|
|
t.Error("Mutex should have been already unlocked by command")
|
|
}
|
|
}
|
|
|
|
func TestJustWaitItOut(t *testing.T) {
|
|
t.Parallel()
|
|
tm := NewTimedMutex(1 * time.Second)
|
|
tm.LockForDuration()
|
|
time.Sleep(2 * time.Second)
|
|
}
|