nim-stew/tests/test_interval_set.nim

391 lines
13 KiB
Nim

# Nimbus - Types, data structures and shared utilities used in network sync
#
# Copyright (c) 2018-2022 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
# http://www.apache.org/licenses/LICENSE-2.0)
# * MIT license ([LICENSE-MIT](LICENSE-MIT) or
# http://opensource.org/licenses/MIT)
# at your option. This file may not be copied, modified, or
# distributed except according to those terms.
{.used.}
import
unittest2,
../stew/interval_set
const
# needs additional import, so this is not standard
TestFrBlockBNumberAlikeOk = false
when TestFrBlockBNumberAlikeOk:
import stint
type FancyScalar = UInt256 # instead of BlockNumber
else:
type FancyScalar = uint64
type
FancyPoint = distinct FancyScalar
FancyRanges = IntervalSetRef[FancyPoint,FancyScalar]
FancyInterval = Interval[FancyPoint,FancyScalar]
const
uHigh = high(uint64)
uLow = low(uint64)
let
ivError = IntervalRc[FancyPoint,FancyScalar].err()
# ------------------------------------------------------------------------------
# Private data type cast helpers
# ------------------------------------------------------------------------------
when 8 < sizeof(FancyScalar): # assuming UInt256:
proc to(num: uint64; T: type FancyScalar): T = num.u256.T
proc to(num: uint64; T: type FancyPoint): T = num.to(FancyScalar).T
else:
proc to(num: uint64; T: type FancyPoint): T = num.T
proc to(num: uint64; T: type FancyScalar): T = num.T
proc truncate(num: FancyScalar; T: type uint64): T = num
# ------------------------------------------------------------------------------
# Private data type interface for `IntervalSet` implementation
# ------------------------------------------------------------------------------
# use a sub-range for `FancyPoint` elements
proc high(T: type FancyPoint): T = uHigh.to(FancyPoint)
proc low(T: type FancyPoint): T = uLow.to(FancyPoint)
proc to(num: FancyPoint; T: type FancyScalar): T = num.T
proc `$`(num: FancyPoint): string = $num.to(FancyScalar)
proc `+`*(a: FancyPoint; b: FancyScalar): FancyPoint =
(a.to(FancyScalar) + b).FancyPoint
proc `-`*(a: FancyPoint; b: FancyScalar): FancyPoint =
(a.to(FancyScalar) - b).FancyPoint
proc `-`*(a, b: FancyPoint): FancyScalar =
(a.to(FancyScalar) - b.to(FancyScalar))
proc `==`*(a, b: FancyPoint): bool = a.to(FancyScalar) == b.to(FancyScalar)
proc `<=`*(a, b: FancyPoint): bool = a.to(FancyScalar) <= b.to(FancyScalar)
proc `<`*(a, b: FancyPoint): bool = a.to(FancyScalar) < b.to(FancyScalar)
# ------------------------------------------------------------------------------
# Private functions
# ------------------------------------------------------------------------------
proc truncate(num: FancyPoint; T: type uint64): uint64 =
num.to(FancyScalar).truncate(uint64)
proc merge(br: FancyRanges; left, right: uint64): uint64 =
let (a, b) = (left.to(FancyPoint), right.to(FancyPoint))
br.merge(a, b).truncate(uint64)
proc reduce(br: FancyRanges; left, right: uint64): uint64 =
let (a, b) = (left.to(FancyPoint), right.to(FancyPoint))
br.reduce(a, b).truncate(uint64)
proc covered(br: FancyRanges; left, right: uint64): uint64 =
let (a, b) = (left.to(FancyPoint), right.to(FancyPoint))
br.covered(a, b).truncate(uint64)
proc delete(br: FancyRanges; start: uint64): Result[FancyInterval,void] =
br.delete(start.to(FancyPoint))
proc le(br: FancyRanges; start: uint64): Result[FancyInterval,void] =
br.le(start.to(FancyPoint))
proc ge(br: FancyRanges; start: uint64): Result[FancyInterval,void] =
br.ge(start.to(FancyPoint))
proc envelope(br: FancyRanges; start: uint64): Result[FancyInterval,void] =
br.envelope(start.to(FancyPoint))
proc iv(left, right: uint64): FancyInterval =
FancyInterval.new(left.to(FancyPoint), right.to(FancyPoint))
# ------------------------------------------------------------------------------
# Test Runner
# ------------------------------------------------------------------------------
suite "IntervalSet: Intervals of FancyPoint entries over FancyScalar":
let br = FancyRanges.init()
var dup: FancyRanges
test "Verify max interval handling":
br.clear()
check br.merge(0,uHigh) == 0
check br.chunks == 1
check br.total == 0
check br.verify.isOk
check br.reduce(uHigh,uHigh) == 1
check br.chunks == 1
check br.total == uHigh.to(FancyScalar)
check br.verify.isOk
test "Verify handling of maximal interval points (edge cases)":
br.clear()
check br.merge(0,uHigh) == 0
check br.reduce(uHigh-1,uHigh-1) == 1
check br.verify.isOk
check br.chunks == 2
check br.total == uHigh.to(FancyScalar)
check br.le(uHigh) == iv(uHigh,uHigh)
check br.le(uHigh-1) == iv(0,uHigh-2)
check br.le(uHigh-2) == iv(0,uHigh-2)
check br.le(uHigh-3) == ivError
check br.ge(0) == iv(0,uHigh-2)
check br.ge(1) == iv(uHigh,uHigh)
check br.ge(uHigh-3) == iv(uHigh,uHigh)
check br.ge(uHigh-2) == iv(uHigh,uHigh)
check br.ge(uHigh-3) == iv(uHigh,uHigh)
check br.ge(uHigh) == iv(uHigh,uHigh)
check br.reduce(0,uHigh-2) == uHigh-1
check br.verify.isOk
check br.chunks == 1
check br.total == 1.to(FancyScalar)
check br.le(uHigh) == iv(uHigh,uHigh)
check br.le(uHigh-1) == ivError
check br.le(uHigh-2) == ivError
check br.le(0) == ivError
check br.ge(uHigh) == iv(uHigh,uHigh)
check br.ge(uHigh-1) == iv(uHigh,uHigh)
check br.ge(uHigh-2) == iv(uHigh,uHigh)
check br.ge(0) == iv(uHigh,uHigh)
br.clear()
check br.total == 0 and br.chunks == 0
check br.merge(0,uHigh) == 0
check br.reduce(0,9999999) == 10000000
check br.total.truncate(uint64) == (uHigh - 10000000) + 1
check br.verify.isOk
check br.merge(uHigh,uHigh) == 0
check br.verify.isOk
check br.reduce(uHigh,uHigh-1) == 1 # same as reduce(uHigh,uHigh)
check br.total.truncate(uint64) == (uHigh - 10000000)
check br.verify.isOk
check br.merge(uHigh,uHigh-1) == 1 # same as merge(uHigh,uHigh)
check br.total.truncate(uint64) == (uHigh - 10000000) + 1
check br.verify.isOk
test "More edge cases detected and fixed":
br.clear()
check br.total == 0 and br.chunks == 0
check br.merge(uHigh,uHigh) == 1
block:
var (ivVal, ivSet) = (iv(0,0), false)
for iv in br.increasing:
check ivSet == false
(ivVal, ivSet) = (iv, true)
check ivVal == iv(uHigh,uHigh)
block:
var (ivVal, ivSet) = (iv(0,0), false)
for iv in br.decreasing:
check ivSet == false
(ivVal, ivSet) = (iv, true)
check ivVal == iv(uHigh,uHigh)
br.clear() # from blockchain sync crash
check br.total == 0 and br.chunks == 0
check br.merge(1477152,uHigh) == uHigh - 1477151
check br.merge(1477151,1477151) == 1
br.clear() # from blockchain snap sync odd behaviour
check br.merge(0,uHigh) == 0
check br.ge(1000) == ivError
check 0 < br.reduce(99999,uHigh-1)
check br.ge(1000) == iv(uHigh,uHigh)
br.clear()
check br.merge(0,uHigh) == 0
check br.le(uHigh) == iv(0,uHigh)
check br.le(uHigh-1) == ivError
check 0 < br.reduce(99999,uHigh-1)
check br.le(uHigh) == iv(uHigh,uHigh)
check br.le(uHigh-1) == iv(0,99998)
check br.le(uHigh-2) == iv(0,99998)
test "Interval envelopes":
br.clear()
check br.merge(0,uHigh) == 0
check br.ge(1000) == ivError
check br.le(1000) == ivError
check br.envelope(1000) == iv(0,uHigh)
check 0 < br.reduce(1000,1000)
check br.envelope(1000) == ivError
check 0 < br.reduce(uHigh,uHigh)
check br.envelope(2000) == iv(1001,uHigh-1)
check br.envelope(uHigh-1) == iv(1001,uHigh-1)
check 0 < br.merge(0,uHigh) # actually == 2
check 0 < br.reduce(uHigh-1,uHigh-1)
check br.envelope(uHigh-1) == ivError
check br.envelope(uHigh-2) == iv(0,uHigh-2)
check br.ge(uHigh) == iv(uHigh,uHigh)
check br.envelope(uHigh) == iv(uHigh,uHigh)
test "Merge overlapping intervals":
br.clear()
check br.merge(100, 199) == 100
check br.merge(150, 200) == 1
check br.total == 101
check br.chunks == 1
check br.verify.isOk
check br.merge( 99, 150) == 1
check br.total == 102
check br.chunks == 1
check br.verify.isOk
test "Merge disjunct intervals on 1st set":
br.clear()
check br.merge( 0, 99) == 100
check br.merge(200, 299) == 100
check br.merge(400, 499) == 100
check br.merge(600, 699) == 100
check br.merge(800, 899) == 100
check br.total == 500
check br.chunks == 5
check br.verify.isOk
test "Reduce non overlapping intervals on 1st set":
check br.reduce(100, 199) == 0
check br.reduce(300, 399) == 0
check br.reduce(500, 599) == 0
check br.reduce(700, 799) == 0
check br.verify.isOk
test "Clone a 2nd set and verify covered data ranges":
dup = br.clone
check dup.covered( 0, 99) == 100
check dup.covered(100, 199) == 0
check dup.covered(200, 299) == 100
check dup.covered(300, 399) == 0
check dup.covered(400, 499) == 100
check dup.covered(500, 599) == 0
check dup.covered(600, 699) == 100
check dup.covered(700, 799) == 0
check dup.covered(800, 899) == 100
check dup.covered(900, uint64.high) == 0
check dup.covered(200, 599) == 200
check dup.covered(200, 799) == 300
check dup.total == 500
check dup.chunks == 5
check dup.verify.isOk
test "Merge overlapping intervals on 2nd set":
check dup.merge( 50, 250) == 100
check dup.merge(450, 850) == 200
check dup.verify.isOk
test "Verify covered data ranges on 2nd set":
check dup.covered( 0, 299) == 300
check dup.covered(300, 399) == 0
check dup.covered(400, 899) == 500
check dup.covered(900, uint64.high) == 0
check dup.total == 800
check dup.chunks == 2
check dup.verify.isOk
test "Verify 1st and 2nd set differ":
check br != dup
test "Reduce overlapping intervals on 2nd set":
check dup.reduce(100, 199) == 100
check dup.reduce(500, 599) == 100
check dup.reduce(700, 799) == 100
check dup.verify.isOk
test "Verify 1st and 2nd set equal":
check br == dup
check br == br
check dup == dup
test "Find intervals in the 1st set":
check br.le(100) == iv( 0, 99)
check br.le(199) == iv( 0, 99)
check br.le(200) == iv( 0, 99)
check br.le(299) == iv(200, 299)
check br.le(999) == iv(800, 899)
check br.le(50) == ivError
check br.ge( 0) == iv( 0, 99)
check br.ge( 1) == iv(200, 299)
check br.ge(800) == iv(800, 899)
check br.ge(801) == ivError
test "Delete intervals from the 2nd set":
check dup.delete(200) == iv(200, 299)
check dup.delete(800) == iv(800, 899)
check dup.verify.isOk
test "Interval intersections":
check iv(100, 199) * iv(150, 249) == iv(150, 199)
check iv(150, 249) * iv(100, 199) == iv(150, 199)
check iv(100, 199) * iv(200, 299) == ivError
check iv(200, 299) * iv(100, 199) == ivError
check iv(200, uHigh) * iv(uHigh,uHigh) == iv(uHigh,uHigh)
check iv(uHigh, uHigh) * iv(200,uHigh) == iv(uHigh,uHigh)
check iv(100, 199) * iv(150, 249) * iv(100, 170) == iv(150, 170)
check (iv(100, 199) * iv(150, 249)) * iv(100, 170) == iv(150, 170)
check iv(100, 199) * (iv(150, 249) * iv(100, 170)) == iv(150, 170)
test "Join intervals":
check iv(100, 199) + iv(150, 249) == iv(100, 249)
check iv(150, 249) + iv(100, 199) == iv(100, 249)
check iv(100, 198) + iv(202, 299) == ivError
check iv(100, 199) + iv(200, 299) == iv(100, 299)
check iv(100, 200) + iv(200, 299) == iv(100, 299)
check iv(100, 201) + iv(200, 299) == iv(100, 299)
check iv(200, 299) + iv(100, 198) == ivError
check iv(200, 299) + iv(100, 199) == iv(100, 299)
check iv(200, 299) + iv(100, 200) == iv(100, 299)
check iv(200, 299) + iv(100, 201) == iv(100, 299)
check iv(200, uHigh) + iv(uHigh,uHigh) == iv(200,uHigh)
check iv(uHigh, uHigh) + iv(200,uHigh) == iv(200,uHigh)
check iv(150, 249) + iv(100, 149) + iv(200, 299) == iv(100, 299)
check (iv(150, 249) + iv(100, 149)) + iv(200, 299) == iv(100, 299)
check iv(150, 249) + (iv(100, 149) + iv(200, 299)) == ivError
test "Cut off intervals by other intervals":
check iv(100, 199) - iv(150, 249) == iv(100, 149)
check iv(150, 249) - iv(100, 199) == iv(200, 249)
check iv(100, 199) - iv(200, 299) == iv(100, 199)
check iv(200, 299) - iv(100, 199) == iv(200, 299)
check iv(200, 399) - iv(250, 349) == ivError
check iv(200, 299) - iv(200, 299) == ivError
check iv(200, 299) - iv(200, 399) == ivError
check iv(200, 299) - iv(100, 299) == ivError
check iv(200, 299) - iv(100, 399) == ivError
check iv(200, 299) - iv(100, 199) - iv(150, 249) == iv(250, 299)
check (iv(200, 299) - iv(100, 199)) - iv(150, 249) == iv(250, 299)
check iv(200, 299) - (iv(100, 199) - iv(150, 249)) == iv(200, 299)
# ------------------------------------------------------------------------------
# End
# ------------------------------------------------------------------------------