synapsecns/sanguine

package mapmutex_test

import (
    "math/rand"
    "strconv"
    "strings"
    "sync"
    "testing"
    "time"

    "github.com/ethereum/go-ethereum/common"
    . "github.com/stretchr/testify/assert"
    "github.com/synapsecns/sanguine/core/mapmutex"
)

// ExampleMapMutex provides an example implementation of a map mutex.
func ExampleStringMapMutex() {
    mapMutex := mapmutex.NewStringMapMutex()
    lock1 := mapMutex.Lock("lock1")
    lock2 := mapMutex.Lock("lock2")

    lock1.Unlock()
    lock2.Unlock()
}

func ExampleStringerMapMutex() {
    vitalik := common.HexToAddress("0xab5801a7d398351b8be11c439e05c5b3259aec9b")
    tether := common.HexToAddress("0xdac17f958d2ee523a2206206994597c13d831ec7")

    mapMutex := mapmutex.NewStringerMapMutex()
    // second variable will be true
    vitalikLock, _ := mapMutex.TryLock(vitalik)
    tetherLock := mapMutex.Lock(tether)

    vitalikLock.Unlock()
    tetherLock.Unlock()
}

func ExampleIntMapMutex() {
    mapMutex := mapmutex.NewIntMapMutex()
    // second variable will be true
    lock0, _ := mapMutex.TryLock(0)
    lock1 := mapMutex.Lock(1)

    lock0.Unlock()
    lock1.Unlock()
}

func (s MapMutexSuite) TestExampleMapMutex() {
    NotPanics(s.T(), ExampleStringMapMutex)
    NotPanics(s.T(), ExampleStringerMapMutex)
    NotPanics(s.T(), ExampleStringMapMutex)
}

func (s MapMutexSuite) TestKeys() {
    s.T().Run("StringMapMutexKeys", func(t *testing.T) {
        mapMutex := mapmutex.NewStringMapMutex()
        mapMutex.Lock("lock1")
        Equal(t, "lock1", mapMutex.Keys()[0])
        Equal(t, 1, len(mapMutex.Keys()))
    })
    s.T().Run("StringerMapMutexKeys", func(t *testing.T) {
        mapMutex := mapmutex.NewStringerMapMutex()
        vitalik := common.HexToAddress("0xab5801a7d398351b8be11c439e05c5b3259aec9b")
        mapMutex.Lock(vitalik)
        Equal(t, vitalik.String(), mapMutex.Keys()[0])
        Equal(t, 1, len(mapMutex.Keys()))
    })
    s.T().Run("IntMapMutexKeys", func(t *testing.T) {
        mapMutex := mapmutex.NewIntMapMutex()
        mapMutex.Lock(1)
        Equal(t, 1, mapMutex.Keys()[0])
        Equal(t, 1, len(mapMutex.Keys()))
    })
}

func (s MapMutexSuite) TestMapMutex() {
    //nolint:gosec
    r := rand.New(rand.NewSource(42))

    m := mapmutex.NewTestMapMutex(s.T())
    _ = m

    keyCount := 20
    iCount := 10000
    out := make(chan string, iCount*2)

    // run a bunch of concurrent requests for various keys,
    // the idea is to have a lot of lock contention
    var wg sync.WaitGroup
    wg.Add(iCount)
    for i := 0; i < iCount; i++ {
        go func(rn int) {
            defer wg.Done()
            key := strconv.Itoa(rn)

            // you can prove the test works by commenting the locking out and seeing it fail
            l := m.Lock(key)
            _, obtained := m.TryLock(key)
            False(s.T(), obtained)
            defer l.Unlock()

            out <- key + " A"
            time.Sleep(time.Microsecond) // make 'em wait a mo'
            out <- key + " B"
        }(r.Intn(keyCount))
    }
    wg.Wait()
    close(out)

    // verify the map is empty now
    if l := len(m.GetMa()); l != 0 {
        s.T().Errorf("unexpected map length at test end: %v", l)
    }

    // confirm that the output always produced the correct sequence
    outLists := make([][]string, keyCount)
    for so := range out {
        sParts := strings.Fields(so)
        kn, err := strconv.Atoi(sParts[0])
        if err != nil {
            s.T().Fatal(err)
        }
        outLists[kn] = append(outLists[kn], sParts[1])
    }
    for kn := 0; kn < keyCount; kn++ {
        l := outLists[kn] // list of output for this particular key
        for i := 0; i < len(l); i += 2 {
            if l[i] != "A" || l[i+1] != "B" {
                s.T().Errorf("For key=%v and i=%v got unexpected values %v and %v", kn, i, l[i], l[i+1])
                break
            }
        }
    }
    if s.T().Failed() {
        s.T().Logf("Failed, outLists: %#v", outLists)
    }
}

func BenchmarkMapMutex(b *testing.B) {
    m := mapmutex.NewTestMapMutex(b)

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        // run uncontended lock/unlock - should be quite fast
        m.Lock(i).Unlock()
    }
}