Clean up comments and tests

src/algo/algo.go

@@ -304,7 +304,7 @@ func bonusAt(input *util.Chars, idx int) int16 {
 
 func normalizeRune(r rune) rune {
 	// Every key of the map folds to ASCII, so a rune the bitmap rejects cannot
-	// be in it. TestNormalizedKeysAreFlagged pins that.
+	// be in it. TestNormalizedKeysAreFlagged verifies that.
 	if !util.MayFoldToAscii(r) {
 		return r
 	}

src/algo/fastpath_equiv_test.go

@@ -1,7 +1,7 @@
 package algo
 
 // Equivalence tests for the single- and two-character fast paths against the
-// general FuzzyMatchV2 algorithm, which serves as the oracle.
+// general FuzzyMatchV2 algorithm, which serves as the reference.
 //
 // Two complementary strategies:
 //   - Exhaustive: every string up to a fixed length over an alphabet that

src/algo/runeprefilter_test.go

@@ -29,9 +29,9 @@ func foldForTest(r rune, normalize bool) rune {
 }
 
 // The prefilter is only safe on items whose runes cannot become ASCII. This
-// pins util.MayFoldToAscii as a superset of the runes that actually can, over
-// the whole Unicode range and both normalization modes. If normalize.go or the
-// Go unicode tables change, this fails.
+// verifies util.MayFoldToAscii as a superset of the runes that actually can,
+// over the whole Unicode range and both normalization modes. If normalize.go
+// or the Go unicode tables change, this fails.
 func TestMayFoldToAsciiIsSuperset(t *testing.T) {
 	missed := 0
 	for r := rune(utf8.RuneSelf); r <= unicode.MaxRune; r++ {
@@ -51,8 +51,8 @@ func TestMayFoldToAsciiIsSuperset(t *testing.T) {
 	}
 }
 
-// Scripts that must stay unflagged, otherwise the prefilter never engages for
-// them and Step C buys nothing.
+// Scripts that must stay unflagged, otherwise the prefilter never runs for
+// them and Step C has no effect.
 func TestMayFoldToAsciiExcludesMajorScripts(t *testing.T) {
 	for _, s := range []struct {
 		name   string
@@ -62,9 +62,9 @@ func TestMayFoldToAsciiExcludesMajorScripts(t *testing.T) {
 		{"Arabic", 0x0600, 0x06FF}, {"Thai", 0x0E00, 0x0E7F}, {"Devanagari", 0x0900, 0x097F},
 		{"CJK", 0x4E00, 0x9FFF}, {"Hangul", 0xAC00, 0xD7A3}, {"kana", 0x3040, 0x30FF},
 		{"box drawing", 0x2500, 0x257F}, {"emoji", 0x1F300, 0x1FAFF},
-		// These sit between the Latin blocks and were swallowed by an earlier,
-		// wider grouping of foldableRanges. General Punctuation is the costly
-		// one: curly quotes, en and em dashes and the ellipsis live there.
+		// These sit between the Latin blocks and were included in an earlier,
+		// wider grouping of foldableRanges. General Punctuation matters most:
+		// curly quotes, en and em dashes and the ellipsis are in it.
 		{"Greek Extended", 0x1F00, 0x1FFF}, {"General Punctuation", 0x2000, 0x206F},
 		{"Currency Symbols", 0x20A0, 0x20CF}, {"CJK Symbols", 0x3000, 0x303F},
 	} {
@@ -257,7 +257,7 @@ func TestNormalizeRuneUnchangedByGuard(t *testing.T) {
 
 // Step G lets non-ASCII pattern runes use the scan, but only when no other
 // rune can transform into them. Being uncased is not sufficient: U+00DF has no
-// simple uppercase yet U+1E9E lowercases onto it. This pins the guard against
+// simple uppercase yet U+1E9E lowercases onto it. This checks the guard against
 // the full preimage relation over all of Unicode.
 func TestRunePrefilterableGuardIsSound(t *testing.T) {
 	preimage := map[rune][]rune{}
@@ -306,7 +306,7 @@ func TestRunePrefilterableGuardIsSound(t *testing.T) {
 	}
 }
 
-// The Step G path must actually engage and reject, otherwise the equivalence
+// The Step G path must actually run and reject, otherwise the equivalence
 // test above proves nothing about non-ASCII patterns.
 func TestNonAsciiPatternPrefilterEngages(t *testing.T) {
 	rng := rand.New(rand.NewSource(6))
@@ -413,7 +413,7 @@ func FuzzRunePrefilter(f *testing.F) {
 		}
 		chars := util.ToChars([]byte(input))
 		if chars.IsBytes() {
-			return // byte mode is the existing fuzzers' territory
+			return // byte mode is covered by the existing fuzzers
 		}
 		for _, cs := range []bool{false, true} {
 			for _, norm := range []bool{false, true} {

src/util/chars.go

@@ -36,9 +36,9 @@ type Chars struct {
 // Rune ranges that case folding or normalization can turn into ASCII, derived
 // from algo's normalization table and unicode.ToLower, then merged. They are a
 // superset of the exact set, which TestMayFoldToAsciiIsSuperset in the algo
-// package pins. Grouped tightly on purpose: a wider merge would swallow Greek
-// Extended, General Punctuation and the currency and letterlike blocks, and
-// every line holding a curly quote or an em dash would then lose the
+// package verifies. Grouped tightly on purpose: a wider merge would include
+// Greek Extended, General Punctuation and the currency and letterlike blocks,
+// and every line holding a curly quote or an em dash would then lose the
 // prefilter. Cyrillic, Greek, Hebrew, Arabic, Thai, Devanagari, CJK, Hangul,
 // kana, emoji, punctuation and box drawing are all outside.
 const (

src/util/chars_test.go

@@ -194,31 +194,19 @@ func TestCharsLinesWrapWord(t *testing.T) {
 		t.Errorf("Expected first line 'abcdefghij', got %q", string(lines2[0]))
 	}
 
-	// Tab as word boundary
-	chars3 := ToChars([]byte("hello\tworld"))
-	lines3, _ := chars3.Lines(false, 100, 7, 0, 8, true)
-	// "hello\t" should break at tab (width of tab at pos 5 with tabstop 8 = 3, total width = 8 > 7)
-	// Actually RunesWidth: 'h'=1,'e'=1,'l'=1,'l'=1,'o'=1,'\t'=3 = 8 > 7, overflowIdx=5
-	// Then word-wrap scans back and finds no space/tab before idx 5 (tab IS at idx 5 but we check line[k-1])
-	// Wait - let me think: overflowIdx=5, we check k=5 -> line[4]='o', k=4 -> line[3]='l'... no space/tab found
-	// Falls back to character wrap: "hello" | "\tworld"
-	if len(lines3) < 2 {
-		t.Errorf("Expected at least 2 lines for tab test, got %d: %v", len(lines3), lines3)
-	}
-
 	// wrapWord=false still character-wraps
-	chars4 := ToChars([]byte("hello world"))
-	lines4, _ := chars4.Lines(false, 100, 8, 0, 8, false)
-	if len(lines4) != 2 {
-		t.Errorf("Expected 2 lines with wrapWord=false, got %d: %v", len(lines4), lines4)
+	chars3 := ToChars([]byte("hello world"))
+	lines3, _ := chars3.Lines(false, 100, 8, 0, 8, false)
+	if len(lines3) != 2 {
+		t.Errorf("Expected 2 lines with wrapWord=false, got %d: %v", len(lines3), lines3)
 	}
-	if string(lines4[0]) != "hello wo" {
-		t.Errorf("Expected first line 'hello wo', got %q", string(lines4[0]))
+	if string(lines3[0]) != "hello wo" {
+		t.Errorf("Expected first line 'hello wo', got %q", string(lines3[0]))
 	}
 }
 
-// Chars is one per input line, so its size is load-bearing. It has no spare
-// padding, which is why new state goes in the flags byte rather than a field.
+// Chars is one per input line, so its size matters. It has no spare padding,
+// which is why new state goes in the flags byte rather than a field.
 // Derive the expectation from the slice header so the invariant holds on
 // 32-bit builds too, where the header is 12 bytes and Chars is 20.
 func TestCharsSize(t *testing.T) {
@@ -260,8 +248,8 @@ func TestMayFoldFlag(t *testing.T) {
 
 // Runes and ToRunes alias the text in rune mode, so a consumer that mutates
 // what they return changes the text without updating the cached fold bit. This
-// pins the aliasing so the read-only contract on those methods is not silently
-// dropped later.
+// verifies the aliasing so the read-only contract on those methods is not
+// silently dropped later.
 func TestRuneSlicesAliasTheText(t *testing.T) {
 	chars := ToChars([]byte("한글abc"))
 	runes := chars.Runes()