synapsecns/sanguine

package util_test

import (
    "fmt"
    "github.com/richardwilkes/toolbox/collection"
    . "github.com/stretchr/testify/assert"
    "github.com/synapsecns/sanguine/ethergo/util"
    "math/big"
    "strings"
    "testing"
)

// make sure are examples don't panic.
func TestChunkExamples(t *testing.T) {
    NotPanics(t, func() {
        ExampleChunk()
    })
}

// ExampleChunk demonstrates ascending and descending chunking.
func ExampleChunk() {
    // a ascending chunk iterator
    chunkIterator := util.NewChunkIterator(big.NewInt(1), big.NewInt(10), 1, true)
    var minMaxChunk, startEndChunks string
    for {
        nextChunk := chunkIterator.NextChunk()
        if nextChunk == nil {
            break
        }

        minMaxChunk += fmt.Sprintf("[%d-%d],", nextChunk.MinBlock(), nextChunk.MaxBlock())
        startEndChunks += fmt.Sprintf("[%d-%d],", nextChunk.StartBlock, nextChunk.EndBlock)
    }
    fmt.Println(strings.TrimSuffix(minMaxChunk, ","))
    fmt.Println(strings.TrimSuffix(startEndChunks, ","))

    // a descending chunk iterator
    chunkIterator = util.NewChunkIterator(big.NewInt(1), big.NewInt(10), 1, false)
    minMaxChunk = ""
    startEndChunks = ""

    for {
        nextChunk := chunkIterator.NextChunk()
        if nextChunk == nil {
            break
        }

        minMaxChunk += fmt.Sprintf("[%d-%d],", nextChunk.MinBlock(), nextChunk.MaxBlock())
        startEndChunks += fmt.Sprintf("[%d-%d],", nextChunk.StartBlock, nextChunk.EndBlock)
    }
    fmt.Println(strings.TrimSuffix(minMaxChunk, ","))
    fmt.Println(strings.TrimSuffix(startEndChunks, ","))
    // output:
    // [1-2],[3-4],[5-6],[7-8],[9-10]
    // [1-2],[3-4],[5-6],[7-8],[9-10]
    // [9-10],[7-8],[5-6],[3-4],[1-2]
    // [10-9],[8-7],[6-5],[4-3],[2-1]
}

// TestChunks runs a test to make sure chunks do not produce dulpicates and correctly end on the last block
// covering start-startBlock fully.
func TestChunks(t *testing.T) {
    t.Parallel()
    ascendingTestCases := []bool{false}
    for _, isAcending := range ascendingTestCases {
        // capture the function literal
        isAcending := isAcending
        t.Run(fmt.Sprintf("ascending: %v", isAcending), func(t *testing.T) {
            t.Parallel()
            testRange(t, isAcending)
        })
    }
}

// testRange tests a block range.
func testRange(tb testing.TB, isAcending bool) {
    tb.Helper()

    startBlock := big.NewInt(100)
    endBlock := big.NewInt(500000)
    // we use an intset to make sure we hit every chunk
    intSet := collection.Set[int]{}

    chunkIterator := util.NewChunkIterator(startBlock, endBlock, 100, isAcending)
    for {
        nextChunk := chunkIterator.NextChunk()
        if nextChunk == nil {
            break
        }

        chunkStart := nextChunk.StartBlock.Uint64()
        chunkEnd := nextChunk.EndBlock.Uint64()

        // make sure min is always less then or equal to max
        True(tb, nextChunk.MaxBlock().Cmp(nextChunk.MinBlock()) >= 0)

        if isAcending {
            for i := chunkStart; i <= chunkEnd; i++ {
                // the item should not be in the intset
                False(tb, intSet.Contains(int(i)))
                intSet.Add(int(i))
            }

            if nextChunk.EndBlock.Cmp(endBlock) != 0 {
                Equal(tb, chunkEnd-chunkStart, uint64(100))
            }
        } else {
            for i := chunkEnd; i <= chunkStart; i++ {
                // the item should not be in the intset
                False(tb, intSet.Contains(int(i)))
                intSet.Add(int(i))
            }

            if nextChunk.EndBlock.Cmp(startBlock) != 0 {
                Equal(tb, chunkStart-chunkEnd, uint64(100))
            }
        }
    }

    if isAcending {
        Equal(tb, uint64(len(intSet)-1), big.NewInt(0).Sub(endBlock, startBlock).Uint64())
    } else {
        Equal(tb, uint64(len(intSet)-1), big.NewInt(0).Sub(startBlock, endBlock).Uint64())
    }
}