Sample range test using IntervalTree

rangeTest.kt

import com.google.common.collect.BoundType
import com.google.common.collect.Range
import com.google.common.collect.TreeRangeMap
import org.junit.Test
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Assertions.assertTrue

class RangeTest {
    data class Rule(val value: String, var updated: Boolean = false)

    private val rangeMap = TreeRangeMap.create<Int, Rule>()

    @Test
    fun run() {
        val rule01 = Rule("1")
        val rule02 = Rule("2")
        val rule03 = Rule("3")
        val rule04 = Rule("4")
        val rule05 = Rule("5")
        val rule06 = Rule("6")

        addRange(1..  10, rule01)
        addRange(5..  8, rule02)
        addRange(8..  20, rule03)
        addRange(10..  12, rule04)
        addRange(30..  40, rule05)
        addRange(30..  40, rule06)

        val intervals: Map<IntRange, Rule> = rangeMap.asMapOfRanges().map {
            it.key.toClosedInterval() to it.value
        }.toMap()

        println(intervals)

        /**
         * Expected:
         * 1-4 rule01
         * 5-7 rule02
         * 8-9 rule03
         * 10-12 rule04
         * 13-20 rule03
         * 30-40 rule06
         */
        intervals.entries.toList().let { intervalList ->
            assertEquals(6, intervalList.size)

            assertEquals(1..4, intervalList[0].key)
            assertEquals(rule01, intervalList[0].value)
            assertTrue(rule01.updated)

            assertEquals(5..7, intervalList[1].key)
            assertEquals(rule02, intervalList[1].value)
            assertTrue(rule02.updated)

            assertEquals(8..9, intervalList[2].key)
            assertEquals(rule03, intervalList[2].value)
            assertTrue(rule03.updated)

            assertEquals(10..12, intervalList[3].key)
            assertEquals(rule04, intervalList[3].value)
            assertFalse(rule04.updated)

            assertEquals(13..20, intervalList[4].key)
            assertEquals(rule03, intervalList[4].value)
            assertTrue(rule05.updated)

            assertEquals(30..40, intervalList[5].key)
            assertEquals(rule06, intervalList[5].value)
            assertFalse(rule06.updated)
        }
    }

    @Test
    fun run2() {
        val rule01 = Rule("1")
        val rule02 = Rule("2")

        addRange(46..  60, rule01)
        addRange(46..  46, rule02)

        val intervals: Map<IntRange, Rule> = rangeMap.asMapOfRanges().map {
            it.key.toClosedInterval() to it.value
        }.toMap()

        println(intervals)

        intervals.entries.toList().let { intervalList ->
            assertEquals(2, intervalList.size)

            assertEquals(46..46, intervalList[0].key)
            assertEquals(rule02, intervalList[0].value)
            assertFalse(rule02.updated)

            assertEquals(47..60, intervalList[1].key)
            assertEquals(rule01, intervalList[1].value)
            assertTrue(rule01.updated)
        }
    }

    private fun addRange(closedRange: ClosedRange<Int>, rule:Rule) {
        val range = Range.closed(closedRange.start, closedRange.endInclusive)

        rangeMap.subRangeMap(range).asMapOfRanges().values.forEach {
            // Mark this Rule as updated
            it.updated = true
        }

        rangeMap.put(range, rule)
    }


    private fun Range<Int>.toClosedInterval(): IntRange {
        val start = when(lowerBoundType()) {
            BoundType.CLOSED -> lowerEndpoint()
            BoundType.OPEN -> lowerEndpoint() + 1
        }

        val end = when(upperBoundType()) {
            BoundType.CLOSED -> upperEndpoint()
            BoundType.OPEN -> upperEndpoint() - 1
        }

        return start..end
    }
}

Output 1:

{1..4=Rule(value=1, updated=true), 5..7=Rule(value=2, updated=true), 8..9=Rule(value=3, updated=true), 10..12=Rule(value=4, updated=false), 13..20=Rule(value=3, updated=true), 30..40=Rule(value=6, updated=false)}

Output 2:

{46..46=Rule(value=2, updated=false), 47..60=Rule(value=1, updated=true)}