snapshot of https://github.com/blevesearch/bleve.git (master, 2026-09-15; blobs > 131072B omitted)

geov2/evaluator_test.go

@@ -0,0 +1,128 @@
+//  Copyright (c) 2026 Couchbase, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 		http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package geov2
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/blevesearch/geo/s2"
+)
+
+func TestBinarySearchLeftmostGreaterOrEqual(t *testing.T) {
+	tests := []struct {
+		name   string
+		arr    []uint64
+		target uint64
+		want   int
+	}{
+		{"empty", nil, 5, 0},
+		{"all less than target", []uint64{1, 2, 3}, 5, 3},
+		{"all greater than target", []uint64{5, 6, 7}, 1, 0},
+		{"exact match", []uint64{1, 3, 5, 7}, 5, 2},
+		{"target between elements", []uint64{1, 3, 5, 7}, 4, 2},
+		{"leftmost of duplicates", []uint64{1, 3, 3, 3, 5}, 3, 1},
+		{"target before all", []uint64{2, 4, 6}, 0, 0},
+		{"target equals last", []uint64{2, 4, 6}, 6, 2},
+		{"single element hit", []uint64{9}, 9, 0},
+		{"single element miss high", []uint64{9}, 10, 1},
+	}
+	for _, test := range tests {
+		if got := binarySearchLeftmostGreaterOrEqual(test.arr, test.target); got != test.want {
+			t.Errorf("%s: binarySearchLeftmostGreaterOrEqual(%v, %d) = %d, want %d",
+				test.name, test.arr, test.target, got, test.want)
+		}
+	}
+}
+
+// TestRangeScanOne verifies the two scoring paths of rangeScanOne: index
+// cells that fall within the query cell's range (the query cell itself and
+// its descendants), and ancestor cells found by walking the query cell's
+// parents (which lie outside the range).
+func TestRangeScanOne(t *testing.T) {
+	const queryLevel = 10
+
+	queryCell := uint64(s2.CellIDFromFace(2).ChildBeginAtLevel(queryLevel))
+	childCell := uint64(s2.CellID(queryCell).ChildBeginAtLevel(12)) // descendant, in range
+	parentCell := uint64(s2.CellID(queryCell).Parent(5))            // ancestor, out of range
+	unrelated := uint64(s2.CellIDFromFace(4).ChildBeginAtLevel(queryLevel))
+
+	// assign each cell a distinct doc ID
+	type entry struct {
+		cell  uint64
+		docID uint32
+	}
+	entries := []entry{
+		{queryCell, 0},
+		{childCell, 1},
+		{parentCell, 2},
+		{unrelated, 3},
+	}
+
+	// index cells must be sorted ascending, with docIds kept parallel
+	sort.Slice(entries, func(i, j int) bool {
+		return entries[i].cell < entries[j].cell
+	})
+	indexCells := make([]uint64, len(entries))
+	docIds := make([]uint32, len(entries))
+	for i, e := range entries {
+		indexCells[i] = e.cell
+		docIds[i] = e.docID
+	}
+
+	scores := make(map[uint32]uint64)
+	minVal, maxVal := getCellSearchBounds(queryCell)
+	rangeScanOne(queryCell, minVal, maxVal, queryLevel, indexCells, docIds, scores)
+
+	// docID 0 is the query cell itself: in range, equal levels
+	if want := calcScore(queryLevel, queryLevel); scores[0] != want {
+		t.Errorf("query cell score = %d, want %d", scores[0], want)
+	}
+	// docID 1 is a descendant at level 12: in range, index cell deeper
+	if want := calcScore(queryLevel, 12); scores[1] != want {
+		t.Errorf("descendant cell score = %d, want %d", scores[1], want)
+	}
+	// docID 2 is an ancestor at level 5: found via the parent walk
+	if want := calcScore(queryLevel, 5); scores[2] != want {
+		t.Errorf("ancestor cell score = %d, want %d", scores[2], want)
+	}
+	// docID 3 is unrelated (different face): must not be scored
+	if scores[3] != 0 {
+		t.Errorf("unrelated cell score = %d, want 0", scores[3])
+	}
+}
+
+// TestRangeScanOneNoMatches confirms that a query cell with no overlapping
+// index cells produces no scores, exercising the empty-range case where
+// end < start.
+func TestRangeScanOneNoMatches(t *testing.T) {
+	const queryLevel = 10
+	queryCell := uint64(s2.CellIDFromFace(0).ChildBeginAtLevel(queryLevel))
+
+	// index cells entirely on a different, non-ancestor part of the tree
+	indexCells := []uint64{
+		uint64(s2.CellIDFromFace(5).ChildBeginAtLevel(queryLevel)),
+		uint64(s2.CellIDFromFace(5).ChildBeginAtLevel(queryLevel).Next()),
+	}
+	docIds := []uint32{0, 1}
+	scores := make(map[uint32]uint64)
+
+	minVal, maxVal := getCellSearchBounds(queryCell)
+	rangeScanOne(queryCell, minVal, maxVal, queryLevel, indexCells, docIds, scores)
+
+	if len(scores) != 0 {
+		t.Errorf("expected no scores, got %d entries: %v", len(scores), scores)
+	}
+}