.

wcfs/internal/xbtree/blib/rangemap_test.go

@@ -32,13 +32,13 @@ func TestRangedMap(t *testing.T) {
 
 	type testEntry struct {
 		A   *RangedMap
-		B   KeyRange
-		Set *RangedMap // A.SetRange(B, x)
+		B   RangedMapEntry
+		Set *RangedMap // A.SetRange(B.keycov, B.value)
 		Del *RangedMap // A.DelRange(B)
 		Has bool       // A.HasRange(B)
 		// XXX Get?
 	}
-	E := func(A *RangedMap, B KeyRange, S, D *RangedMap, H bool) testEntry {
+	E := func(A *RangedMap, B RangedMapEntry, S, D *RangedMap, H bool) testEntry {
 		return testEntry{A, B, S, D, H}
 	}
 
@@ -72,13 +72,13 @@ func TestRangedMap(t *testing.T) {
 		return M
 	}
 
-	// K creates [lo,hi) KeyRange
-	K := func(lo,hi Key) KeyRange {
+	// K creates RangedMapEntry{v, [lo,hi)}
+	K := func(lo,hi Key, v string) RangedMapEntry {
 		hi_ := hi
 		if hi_ != noo {
 			hi_--
 		}
-		return KeyRange{lo, hi_}
+		return RangedMapEntry{v, KeyRange{lo, hi_}}
 	}
 
 	// y, n alias true/false
@@ -88,41 +88,65 @@ func TestRangedMap(t *testing.T) {
 	const a, b, c, d, x = "a", "b", "c", "d", "x"
 
 
-	// XXX SetRange:
-	// - coalesce (value same)
-	// - shrink left/right (value !same) + new entry
-
-
 	testv := []testEntry{
 		E(
 			M(1,2,a, 2,3,b),	// A
-			K(1,3),			// B
+			K(1,3,x),		// B
 				M(1,3,x),		// Set
 				M(),			// Del
 				y),			// Has
+
+		// coalesce (same value, no overlap)
+		E(
+			M(1,2,a, 4,5,a),	// A
+			K(2,4,a),		// B
+				M(1,5,a),		// Set
+				M(1,2,a, 4,5,a),	// Del
+				n),			// Has
+
+		// coalesce (same value, overlap)
+		E(
+			M(1,4,a, 5,8,a),	// A
+			K(2,6,a),		// B
+				M(1,8,a),		// Set
+				M(1,2,a, 6,8,a),	// Del
+				n),			// Has
+
+		// - shrink left/right (value !same) + new entry
+		E(
+			M(1,4,a, 5,8,b),	// A
+			K(2,6,x),		// B
+				M(1,2,a, 2,6,x, 6,8,b),	// Set
+				M(1,2,a,        6,8,b), // Del
+				n),                     // Has
+
+
+
 	}
 
 	for _, tt := range testv {
 		A := tt.A
 		B := tt.B
+		r := B.KeyRange
+		v := B.Value
 
-		has := A.HasRange(B)
+		has := A.HasRange(r)
 		Aset := A.Clone()
 		Adel := A.Clone()
-		Aset.SetRange(B, x)
-		Adel.DelRange(B)
+		Aset.SetRange(r, v)
+		Adel.DelRange(r)
 
 		if !(has == tt.Has) {
-			t.Errorf("HasRange:\n  A:   %s\n  B:   %s\n  ->·: %t\n  ok·: %t\n", A, B, has, tt.Has)
+			t.Errorf("HasRange:\n  A:   %s\n  r:   %s\n  ->·: %t\n  ok·: %t\n", A, r, has, tt.Has)
 		}
 
 		if !Aset.Equal(tt.Set) {
-			t.Errorf("SetRange:\n  A:   %s\n  B:   %s\n  ->·: %s\n  ok·: %s\n", A, RangedMapEntry{x,B}, Aset, tt.Set)
+			t.Errorf("SetRange:\n  A:   %s\n  e:   %s\n  ->·: %s\n  ok·: %s\n", A, B, Aset, tt.Set)
 
 		}
 
 		if !Adel.Equal(tt.Del) {
-			t.Errorf("DelRange:\n  A:   %s\n  B:   %s\n  ->·: %s\n  ok·: %s\n", A, B, Adel, tt.Del)
+			t.Errorf("DelRange:\n  A:   %s\n  r:   %s\n  ->·: %s\n  ok·: %s\n", A, r, Adel, tt.Del)
 
 		}