path: root/swarm/network/stream/intervals/intervals_test.go

// Copyright 2018 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package intervals

import "testing"

// Test tests Interval methods Add, Next and Last for various
// initial state.
func Test(t *testing.T) {
    for i, tc := range []struct {
        startLimit uint64
        initial    [][2]uint64
        start      uint64
        end        uint64
        expected   string
        nextStart  uint64
        nextEnd    uint64
        last       uint64
    }{
        {
            initial:   nil,
            start:     0,
            end:       0,
            expected:  "[[0 0]]",
            nextStart: 1,
            nextEnd:   0,
            last:      0,
        },
        {
            initial:   nil,
            start:     0,
            end:       10,
            expected:  "[[0 10]]",
            nextStart: 11,
            nextEnd:   0,
            last:      10,
        },
        {
            initial:   nil,
            start:     5,
            end:       15,
            expected:  "[[5 15]]",
            nextStart: 0,
            nextEnd:   4,
            last:      15,
        },
        {
            initial:   [][2]uint64{{0, 0}},
            start:     0,
            end:       0,
            expected:  "[[0 0]]",
            nextStart: 1,
            nextEnd:   0,
            last:      0,
        },
        {
            initial:   [][2]uint64{{0, 0}},
            start:     5,
            end:       15,
            expected:  "[[0 0] [5 15]]",
            nextStart: 1,
            nextEnd:   4,
            last:      15,
        },
        {
            initial:   [][2]uint64{{5, 15}},
            start:     5,
            end:       15,
            expected:  "[[5 15]]",
            nextStart: 0,
            nextEnd:   4,
            last:      15,
        },
        {
            initial:   [][2]uint64{{5, 15}},
            start:     5,
            end:       20,
            expected:  "[[5 20]]",
            nextStart: 0,
            nextEnd:   4,
            last:      20,
        },
        {
            initial:   [][2]uint64{{5, 15}},
            start:     10,
            end:       20,
            expected:  "[[5 20]]",
            nextStart: 0,
            nextEnd:   4,
            last:      20,
        },
        {
            initial:   [][2]uint64{{5, 15}},
            start:     0,
            end:       20,
            expected:  "[[0 20]]",
            nextStart: 21,
            nextEnd:   0,
            last:      20,
        },
        {
            initial:   [][2]uint64{{5, 15}},
            start:     2,
            end:       10,
            expected:  "[[2 15]]",
            nextStart: 0,
            nextEnd:   1,
            last:      15,
        },
        {
            initial:   [][2]uint64{{5, 15}},
            start:     2,
            end:       4,
            expected:  "[[2 15]]",
            nextStart: 0,
            nextEnd:   1,
            last:      15,
        },
        {
            initial:   [][2]uint64{{5, 15}},
            start:     2,
            end:       5,
            expected:  "[[2 15]]",
            nextStart: 0,
            nextEnd:   1,
            last:      15,
        },
        {
            initial:   [][2]uint64{{5, 15}},
            start:     2,
            end:       3,
            expected:  "[[2 3] [5 15]]",
            nextStart: 0,
            nextEnd:   1,
            last:      15,
        },
        {
            initial:   [][2]uint64{{5, 15}},
            start:     2,
            end:       4,
            expected:  "[[2 15]]",
            nextStart: 0,
            nextEnd:   1,
            last:      15,
        },
        {
            initial:   [][2]uint64{{0, 1}, {5, 15}},
            start:     2,
            end:       4,
            expected:  "[[0 15]]",
            nextStart: 16,
            nextEnd:   0,
            last:      15,
        },
        {
            initial:   [][2]uint64{{0, 5}, {15, 20}},
            start:     2,
            end:       10,
            expected:  "[[0 10] [15 20]]",
            nextStart: 11,
            nextEnd:   14,
            last:      20,
        },
        {
            initial:   [][2]uint64{{0, 5}, {15, 20}},
            start:     8,
            end:       18,
            expected:  "[[0 5] [8 20]]",
            nextStart: 6,
            nextEnd:   7,
            last:      20,
        },
        {
            initial:   [][2]uint64{{0, 5}, {15, 20}},
            start:     2,
            end:       17,
            expected:  "[[0 20]]",
            nextStart: 21,
            nextEnd:   0,
            last:      20,
        },
        {
            initial:   [][2]uint64{{0, 5}, {15, 20}},
            start:     2,
            end:       25,
            expected:  "[[0 25]]",
            nextStart: 26,
            nextEnd:   0,
            last:      25,
        },
        {
            initial:   [][2]uint64{{0, 5}, {15, 20}},
            start:     5,
            end:       14,
            expected:  "[[0 20]]",
            nextStart: 21,
            nextEnd:   0,
            last:      20,
        },
        {
            initial:   [][2]uint64{{0, 5}, {15, 20}},
            start:     6,
            end:       14,
            expected:  "[[0 20]]",
            nextStart: 21,
            nextEnd:   0,
            last:      20,
        },
        {
            initial:   [][2]uint64{{0, 5}, {15, 20}, {30, 40}},
            start:     6,
            end:       29,
            expected:  "[[0 40]]",
            nextStart: 41,
            nextEnd:   0,
            last:      40,
        },
        {
            initial:   [][2]uint64{{0, 5}, {15, 20}, {30, 40}, {50, 60}},
            start:     3,
            end:       55,
            expected:  "[[0 60]]",
            nextStart: 61,
            nextEnd:   0,
            last:      60,
        },
        {
            initial:   [][2]uint64{{0, 5}, {15, 20}, {30, 40}, {50, 60}},
            start:     21,
            end:       49,
            expected:  "[[0 5] [15 60]]",
            nextStart: 6,
            nextEnd:   14,
            last:      60,
        },
        {
            initial:   [][2]uint64{{0, 5}, {15, 20}, {30, 40}, {50, 60}},
            start:     0,
            end:       100,
            expected:  "[[0 100]]",
            nextStart: 101,
            nextEnd:   0,
            last:      100,
        },
        {
            startLimit: 100,
            initial:    nil,
            start:      0,
            end:        0,
            expected:   "[]",
            nextStart:  100,
            nextEnd:    0,
            last:       0,
        },
        {
            startLimit: 100,
            initial:    nil,
            start:      20,
            end:        30,
            expected:   "[]",
            nextStart:  100,
            nextEnd:    0,
            last:       0,
        },
        {
            startLimit: 100,
            initial:    nil,
            start:      50,
            end:        100,
            expected:   "[[100 100]]",
            nextStart:  101,
            nextEnd:    0,
            last:       100,
        },
        {
            startLimit: 100,
            initial:    nil,
            start:      50,
            end:        110,
            expected:   "[[100 110]]",
            nextStart:  111,
            nextEnd:    0,
            last:       110,
        },
        {
            startLimit: 100,
            initial:    nil,
            start:      120,
            end:        130,
            expected:   "[[120 130]]",
            nextStart:  100,
            nextEnd:    119,
            last:       130,
        },
        {
            startLimit: 100,
            initial:    nil,
            start:      120,
            end:        130,
            expected:   "[[120 130]]",
            nextStart:  100,
            nextEnd:    119,
            last:       130,
        },
    } {
        intervals := NewIntervals(tc.startLimit)
        intervals.ranges = tc.initial
        intervals.Add(tc.start, tc.end)
        got := intervals.String()
        if got != tc.expected {
            t.Errorf("interval #%d: expected %s, got %s", i, tc.expected, got)
        }
        nextStart, nextEnd := intervals.Next()
        if nextStart != tc.nextStart {
            t.Errorf("interval #%d, expected next start %d, got %d", i, tc.nextStart, nextStart)
        }
        if nextEnd != tc.nextEnd {
            t.Errorf("interval #%d, expected next end %d, got %d", i, tc.nextEnd, nextEnd)
        }
        last := intervals.Last()
        if last != tc.last {
            t.Errorf("interval #%d, expected last %d, got %d", i, tc.last, last)
        }
    }
}

func TestMerge(t *testing.T) {
    for i, tc := range []struct {
        initial  [][2]uint64
        merge    [][2]uint64
        expected string
    }{
        {
            initial:  nil,
            merge:    nil,
            expected: "[]",
        },
        {
            initial:  [][2]uint64{{10, 20}},
            merge:    nil,
            expected: "[[10 20]]",
        },
        {
            initial:  nil,
            merge:    [][2]uint64{{15, 25}},
            expected: "[[15 25]]",
        },
        {
            initial:  [][2]uint64{{0, 100}},
            merge:    [][2]uint64{{150, 250}},
            expected: "[[0 100] [150 250]]",
        },
        {
            initial:  [][2]uint64{{0, 100}},
            merge:    [][2]uint64{{101, 250}},
            expected: "[[0 250]]",
        },
        {
            initial:  [][2]uint64{{0, 10}, {30, 40}},
            merge:    [][2]uint64{{20, 25}, {41, 50}},
            expected: "[[0 10] [20 25] [30 50]]",
        },
        {
            initial:  [][2]uint64{{0, 5}, {15, 20}, {30, 40}, {50, 60}},
            merge:    [][2]uint64{{6, 25}},
            expected: "[[0 25] [30 40] [50 60]]",
        },
    } {
        intervals := NewIntervals(0)
        intervals.ranges = tc.initial
        m := NewIntervals(0)
        m.ranges = tc.merge

        intervals.Merge(m)

        got := intervals.String()
        if got != tc.expected {
            t.Errorf("interval #%d: expected %s, got %s", i, tc.expected, got)
        }
    }
}