Changed begins and ends calculation for consistancy

Author: freakmaxi

data-node/cache/container.go

@@ -71,25 +71,24 @@ func (i *indexItem) MatchRange(begins uint32, ends uint32) []byte {
 			startIndex := begins - dC.begins
 			remainSize := dC.Size() - startIndex
 			if ends < dC.ends {
-				remainSize = ends - begins + 1
+				remainSize = ends - begins
 			}
 
 			compiledData = append(compiledData, dC.data[startIndex:startIndex+remainSize]...)
-			begins += remainSize - 1
+			begins += remainSize
 
 			if begins == ends {
 				return compiledData
 			}
-
-			// if still needs to be filled, so move one byte forward not to repeat the same byte
-			begins++
 		}
 	}
 
 	return nil
 }
 
 // Merge returns current size and new size after merge
+// ends is the ending index and not included
+// begins = 6, ends: 10 length should be 4 indices are 6 7 8 9
 func (i *indexItem) Merge(begins uint32, ends uint32, data []byte) (uint64, uint64) {
 	currentSize := i.Size()
 
@@ -150,7 +149,7 @@ func (i *indexItem) Merge(begins uint32, ends uint32, data []byte) (uint64, uint
 				continue
 			}
 
-			mergingContainer.data = append(mergingContainer.data, dC.data[remainsBegins-dC.begins+1:]...)
+			mergingContainer.data = append(mergingContainer.data, dC.data[remainsBegins-dC.begins:]...)
 			mergingContainer.ends += dC.ends - remainsBegins
 
 			i.dataItems = append(i.dataItems[0:idx], i.dataItems[idx+1:]...)

data-node/cache/container_test.go

@@ -138,51 +138,54 @@ func TestIndexItem_MatchRangeV1(t *testing.T) {
 		dataItems: []dataContainer{
 			{
 				begins: 21,
-				ends:   29,
+				ends:   30,
 				data:   []byte{0, 1, 2, 3, 4, 5, 6, 7, 8},
 			},
 			{
 				begins: 30,
-				ends:   35,
+				ends:   36,
 				data:   []byte{9, 10, 11, 12, 13, 14},
 			},
 			{
 				begins: 37,
-				ends:   40,
+				ends:   41,
 				data:   []byte{16, 17, 18, 19},
 			},
 			{
 				begins: 41,
-				ends:   44,
-				data:   []byte{20, 21, 23, 24},
+				ends:   45,
+				data:   []byte{20, 21, 22, 23},
 			},
 			{
 				begins: 45,
-				ends:   50,
-				data:   []byte{25, 26, 27, 28, 29, 30},
+				ends:   52,
+				data:   []byte{24, 25, 26, 27, 28, 29, 30},
 			},
 		},
 	}
 
 	result1 := item.MatchRange(24, 28)
-	assert.Equal(t, []byte{3, 4, 5, 6, 7}, result1)
+	assert.Equal(t, []byte{3, 4, 5, 6}, result1)
 
 	result2 := item.MatchRange(21, 29)
-	assert.Equal(t, []byte{0, 1, 2, 3, 4, 5, 6, 7, 8}, result2)
+	assert.Equal(t, []byte{0, 1, 2, 3, 4, 5, 6, 7}, result2)
+
+	result2_1 := item.MatchRange(21, 30)
+	assert.Equal(t, []byte{0, 1, 2, 3, 4, 5, 6, 7, 8}, result2_1)
 
 	result3 := item.MatchRange(28, 33)
-	assert.Equal(t, []byte{7, 8, 9, 10, 11, 12}, result3)
+	assert.Equal(t, []byte{7, 8, 9, 10, 11}, result3)
 
 	result4 := item.MatchRange(28, 38)
 	assert.Nil(t, result4)
 
-	result5 := item.MatchRange(37, 50)
-	assert.Equal(t, []byte{16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30}, result5)
+	result5 := item.MatchRange(37, 52)
+	assert.Equal(t, []byte{16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30}, result5)
 
 	result6 := item.MatchRange(19, 28)
 	assert.Nil(t, result6)
 
-	result7 := item.MatchRange(37, 51)
+	result7 := item.MatchRange(36, 51)
 	assert.Nil(t, result7)
 
 	result8 := item.MatchRange(0, 0)
@@ -245,69 +248,60 @@ func TestIndexItem_MergeV1(t *testing.T) {
 		dataItems: []dataContainer{
 			{
 				begins: 21,
-				ends:   29,
+				ends:   30,
 				data:   []byte{0, 1, 2, 3, 4, 5, 6, 7, 8},
 			},
 			{
 				begins: 24,
-				ends:   28,
+				ends:   29,
 				data:   []byte{3, 4, 5, 6, 7},
 			},
 			{
 				begins: 27,
-				ends:   32,
+				ends:   33,
 				data:   []byte{6, 7, 8, 9, 10, 11},
 			},
 			{
 				begins: 41,
-				ends:   44,
+				ends:   45,
 				data:   []byte{20, 21, 23, 24},
 			},
 			{
 				begins: 45,
-				ends:   50,
+				ends:   51,
 				data:   []byte{25, 26, 27, 28, 29, 30},
 			},
 		},
 	}
 
-	item.Merge(33, 39, []byte{12, 13, 14, 15, 16, 17, 18})
+	item.Merge(34, 38, []byte{13, 14, 15, 16})
 
 	assert.Equal(t,
 		dataContainer{
 			data:   []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
 			begins: 21,
-			ends:   32,
+			ends:   33,
 		},
 		item.dataItems[0],
 	)
 
 	assert.Equal(t,
 		dataContainer{
-			data:   []byte{12, 13, 14, 15, 16, 17, 18},
-			begins: 33,
-			ends:   39,
+			data:   []byte{13, 14, 15, 16},
+			begins: 34,
+			ends:   38,
 		},
 		item.dataItems[1],
 	)
 
 	assert.Equal(t,
 		dataContainer{
 			begins: 41,
-			ends:   44,
-			data:   []byte{20, 21, 23, 24},
+			ends:   51,
+			data:   []byte{20, 21, 23, 24, 25, 26, 27, 28, 29, 30},
 		},
 		item.dataItems[2],
 	)
-
-	assert.Equal(t,
-		dataContainer{
-			begins: 45,
-			ends:   50,
-			data:   []byte{25, 26, 27, 28, 29, 30},
-		},
-		item.dataItems[3],
-	)
 }
 
 func TestIndexItem_MergeV2(t *testing.T) {
@@ -319,27 +313,27 @@ func TestIndexItem_MergeV2(t *testing.T) {
 		dataItems: []dataContainer{
 			{
 				begins: 21,
-				ends:   29,
+				ends:   30,
 				data:   []byte{0, 1, 2, 3, 4, 5, 6, 7, 8},
 			},
 			{
 				begins: 24,
-				ends:   28,
+				ends:   29,
 				data:   []byte{3, 4, 5, 6, 7},
 			},
 			{
 				begins: 27,
-				ends:   32,
+				ends:   33,
 				data:   []byte{6, 7, 8, 9, 10, 11},
 			},
 			{
 				begins: 41,
-				ends:   44,
+				ends:   45,
 				data:   []byte{20, 21, 23, 24},
 			},
 			{
 				begins: 45,
-				ends:   50,
+				ends:   51,
 				data:   []byte{25, 26, 27, 28, 29, 30},
 			},
 		},
@@ -359,7 +353,7 @@ func TestIndexItem_MergeV2(t *testing.T) {
 	assert.Equal(t,
 		dataContainer{
 			begins: 41,
-			ends:   44,
+			ends:   45,
 			data:   []byte{20, 21, 23, 24},
 		},
 		item.dataItems[1],
@@ -368,7 +362,7 @@ func TestIndexItem_MergeV2(t *testing.T) {
 	assert.Equal(t,
 		dataContainer{
 			begins: 45,
-			ends:   50,
+			ends:   51,
 			data:   []byte{25, 26, 27, 28, 29, 30},
 		},
 		item.dataItems[2],
@@ -384,39 +378,39 @@ func TestIndexItem_MergeV3(t *testing.T) {
 		dataItems: []dataContainer{
 			{
 				begins: 21,
-				ends:   29,
+				ends:   30,
 				data:   []byte{0, 1, 2, 3, 4, 5, 6, 7, 8},
 			},
 			{
 				begins: 24,
-				ends:   28,
+				ends:   29,
 				data:   []byte{3, 4, 5, 6, 7},
 			},
 			{
 				begins: 27,
-				ends:   32,
+				ends:   33,
 				data:   []byte{6, 7, 8, 9, 10, 11},
 			},
 			{
 				begins: 41,
-				ends:   44,
+				ends:   45,
 				data:   []byte{20, 21, 23, 24},
 			},
 			{
 				begins: 45,
-				ends:   50,
+				ends:   51,
 				data:   []byte{25, 26, 27, 28, 29, 30},
 			},
 		},
 	}
 
-	item.Merge(21, 50, []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30})
+	item.Merge(21, 51, []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30})
 
 	assert.Equal(t,
 		dataContainer{
 			data:   []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30},
 			begins: 21,
-			ends:   50,
+			ends:   51,
 		},
 		item.dataItems[0],
 	)
@@ -431,33 +425,33 @@ func TestIndexItem_MergeV4(t *testing.T) {
 		dataItems: []dataContainer{
 			{
 				begins: 21,
-				ends:   29,
+				ends:   30,
 				data:   []byte{0, 1, 2, 3, 4, 5, 6, 7, 8},
 			},
 			{
 				begins: 24,
-				ends:   28,
+				ends:   29,
 				data:   []byte{3, 4, 5, 6, 7},
 			},
 			{
 				begins: 27,
-				ends:   32,
+				ends:   33,
 				data:   []byte{6, 7, 8, 9, 10, 11},
 			},
 			{
 				begins: 41,
-				ends:   44,
+				ends:   45,
 				data:   []byte{20, 21, 23, 24},
 			},
 			{
 				begins: 45,
-				ends:   50,
+				ends:   51,
 				data:   []byte{25, 26, 27, 28, 29, 30},
 			},
 		},
 	}
 
-	item.Merge(0, 0, []byte{0, 1, 2, 3, 4, 5, 6})
+	oldSize, newSize := item.Merge(0, 0, []byte{0, 1, 2, 3, 4, 5, 6})
 
 	assert.Equal(t,
 		dataContainer{
@@ -467,45 +461,10 @@ func TestIndexItem_MergeV4(t *testing.T) {
 		},
 		item.dataItems[0],
 	)
-}
-
-func TestIndexItem_MergeV5(t *testing.T) {
-	item := indexItem{
-		sha512Hex: "test",
-		expiresAt: time.Now(),
-		sortIndex: 0,
-
-		dataItems: []dataContainer{
-			{
-				begins: 21,
-				ends:   29,
-				data:   []byte{0, 1, 2, 3, 4, 5, 6, 7, 8},
-			},
-			{
-				begins: 24,
-				ends:   28,
-				data:   []byte{3, 4, 5, 6, 7},
-			},
-			{
-				begins: 27,
-				ends:   32,
-				data:   []byte{6, 7, 8, 9, 10, 11},
-			},
-			{
-				begins: 41,
-				ends:   44,
-				data:   []byte{20, 21, 23, 24},
-			},
-			{
-				begins: 45,
-				ends:   50,
-				data:   []byte{25, 26, 27, 28, 29, 30},
-			},
-		},
-	}
-
-	oldSize, newSize := item.Merge(0, 0, []byte{0, 1, 2, 3, 4, 5, 6})
 
 	assert.Equal(t, uint64(30), oldSize)
 	assert.Equal(t, uint64(7), newSize)
+
+	result1 := item.MatchRange(2, 5)
+	assert.Equal(t, []byte{2, 3, 4}, result1)
 }