1 files changed, 79 insertions, 36 deletions

diff --git a/pkg/libs/rangemap/rangemap_test.go b/pkg/libs/rangemap/rangemap_test.go
index b120efa..deb6dc7 100644
--- a/pkg/libs/rangemap/rangemap_test.go
+++ b/pkg/libs/rangemap/rangemap_test.go
@@ -7,65 +7,108 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestAppend(t *testing.T) {
+func TestAppendAndGet(t *testing.T) {
 	rm := rangemap.New[string]()
 
-	assert.True(t, rm.AppendToLast(0, "a"))
-	assert.True(t, rm.AppendToLast(1, "b"))
-	assert.True(t, rm.AppendToLast(4, "c"))
+	rm.AppendToLast(0, "a")
+	rm.AppendToLast(1, "b")
+	rm.AppendToLast(4, "c")
+
+	assert.Equal(t, "a", *rm.Get(0))
+	assert.Equal(t, "b", *rm.Get(1))
+	assert.Equal(t, "c", *rm.Get(2))
+	assert.Equal(t, "c", *rm.Get(3))
+	assert.Equal(t, "c", *rm.Get(4))
 }
 
-func TestAppendAndGet(t *testing.T) {
+func TestEmpty(t *testing.T) {
+	rm := rangemap.New[int]()
+
+	assert.Nil(t, rm.Get(0))
+	assert.Nil(t, rm.Get(1))
+	assert.Nil(t, rm.Get(2))
+	assert.Nil(t, rm.Get(-1))
+}
+
+func TestNoOverlap(t *testing.T) {
+	rm := rangemap.New[string]()
+
+	rm.Set(0, 2, "a")
+	rm.Set(3, 3, "b")
+	rm.Set(4, 7, "c")
+
+	assert.Equal(t, "a", *rm.Get(0))
+	assert.Equal(t, "a", *rm.Get(1))
+	assert.Equal(t, "a", *rm.Get(2))
+
+	assert.Equal(t, "b", *rm.Get(3))
+
+	assert.Equal(t, "c", *rm.Get(4))
+	assert.Equal(t, "c", *rm.Get(5))
+	assert.Equal(t, "c", *rm.Get(6))
+	assert.Equal(t, "c", *rm.Get(7))
+
+	assert.Nil(t, rm.Get(8))
+
+	assert.Equal(t, "[{0..2: a}, {3..3: b}, {4..7: c}, {8..-1}]", rm.String())
+}
+
+func TestOverlap(t *testing.T) {
 	rm := rangemap.New[string]()
 
-	assert.True(t, rm.AppendToLast(0, "a"))
-	assert.True(t, rm.AppendToLast(1, "b"))
-	assert.True(t, rm.AppendToLast(4, "c"))
+	rm.Set(0, 2, "a")
+	rm.Set(3, 5, "b")
+	rm.Set(6, 10, "c")
 
-	a, ok := rm.Get(0)
-	assert.True(t, ok)
-	assert.Equal(t, "a", *a)
+	rm.Set(4, 8, "x")
 
-	b, ok := rm.Get(1)
-	assert.True(t, ok)
-	assert.Equal(t, "b", *b)
+	assert.Equal(t, "[{0..2: a}, {3..3: b}, {4..8: x}, {9..10: c}, {11..-1}]", rm.String())
+}
 
-	cfrom, ok := rm.Get(2)
-	assert.True(t, ok)
-	assert.Equal(t, "c", *cfrom)
+func TestOverwrite(t *testing.T) {
+	rm := rangemap.New[string]()
 
-	cmid, ok := rm.Get(3)
-	assert.True(t, ok)
-	assert.Equal(t, "c", *cmid)
+	rm.Set(0, 2, "a")
+	rm.Set(3, 5, "b")
+	rm.Set(6, 10, "c")
 
-	cto, ok := rm.Get(4)
-	assert.True(t, ok)
-	assert.Equal(t, "c", *cto)
+	rm.Set(3, 9, "x")
+
+	assert.Equal(t, "[{0..2: a}, {3..9: x}, {10..10: c}, {11..-1}]", rm.String())
 }
 
-func TestWrongAppend(t *testing.T) {
+func TestOverwriteInBetween(t *testing.T) {
 	rm := rangemap.New[string]()
 
-	assert.True(t, rm.AppendToLast(0, "a"))
-	assert.False(t, rm.AppendToLast(0, "b"))
+	rm.Set(0, 2, "a")
+	rm.Set(3, 4, "b")
+	rm.Set(5, 5, "c")
+	rm.Set(6, 10, "d")
+
+	rm.Set(3, 9, "x")
+
+	assert.Equal(t, "[{0..2: a}, {3..9: x}, {10..10: d}, {11..-1}]", rm.String())
 }
 
-func TestUnknownRange(t *testing.T) {
+func TestPerfectFit(t *testing.T) {
 	rm := rangemap.New[string]()
 
-	assert.True(t, rm.AppendToLast(6, "a"))
+	rm.Set(0, 2, "a")
+	rm.Set(5, 6, "b")
 
-	a, ok := rm.Get(6)
-	assert.True(t, ok)
-	assert.Equal(t, "a", *a)
+	rm.Set(3, 4, "x")
 
-	b, ok := rm.Get(7)
-	assert.False(t, ok)
-	assert.Nil(t, b)
+	assert.Equal(t, "[{0..2: a}, {3..4: x}, {5..6: b}, {7..-1}]", rm.String())
 }
 
-func TestNegativeAppend(t *testing.T) {
+func TestSpaceBetween(t *testing.T) {
 	rm := rangemap.New[string]()
 
-	assert.False(t, rm.AppendToLast(-1, "a"))
+	rm.Set(0, 2, "a")
+	rm.Set(9, 9, "b")
+
+	rm.Set(4, 6, "x")
+
+	// Since our search can never fail, we pad the space with a sentinel value.
+	assert.Equal(t, "[{0..2: a}, {3..3}, {4..6: x}, {7..8}, {9..9: b}, {10..-1}]", rm.String())
 }