Enforce minimumLength >= 1 in JapaneseKatakanaStemFilter (LUCENE-10352 backport), #1072

Backport the upstream LUCENE-10352 constructor guard so JapaneseKatakanaStemFilter
rejects a minimumLength less than 1, matching apache/lucene
(JapaneseKatakanaStemFilter.java: "minimumLength must be >=1"). This replaces the
prior Stem() length==0 guard from the previous commit with the upstream approach.

A minimumLength of 0 let a zero-length token (e.g. the single empty token a
KeywordTokenizer emits for empty input) skip the "length < minimumKatakanaLength"
check in Stem(), after which the term[length - 1] access read term[-1] and threw
IndexOutOfRangeException. Enforcing minimumLength >= 1 in the constructor prevents
that configuration from being built at all, which is how upstream resolved it.

This was the residual TestRandomChains failure reported on PR #1348 (seeds
0x951afd480395f9b7:0x63fc16274945f1a3 / es-419 and
0xa4b2f7f450b03294:0x9fdf3b0c216c251e / lt-LT): the random arg producer can yield
minimumLength of 0, and TestRandomChains already discards constructors that throw
ArgumentOutOfRangeException, so the offending chain is simply skipped.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: paulirwin

src/Lucene.Net.Analysis.Kuromoji/JapaneseKatakanaStemFilter.cs

@@ -51,9 +51,11 @@ public sealed class JapaneseKatakanaStemFilter : TokenFilter
         public JapaneseKatakanaStemFilter(TokenStream input, int minimumLength)
             : base(input)
         {
-            // LUCENENET: Added guard clause
-            if (minimumLength < 0)
-                throw new ArgumentOutOfRangeException(nameof(minimumLength), "Minimum length must be a non-negative integer.");
+            // LUCENENET: Backport of the LUCENE-10352 guard clause. Enforcing minimumLength >= 1
+            // prevents a zero-length term (e.g. the single empty token a KeywordTokenizer emits for
+            // empty input) from reaching the term[length - 1] read in Stem() with length == 0.
+            if (minimumLength < 1)
+                throw new ArgumentOutOfRangeException(nameof(minimumLength), "minimumLength must be >=1");
 
             this.minimumKatakanaLength = minimumLength;
             this.termAttr = AddAttribute<ICharTermAttribute>();
@@ -83,18 +85,6 @@ public override bool IncrementToken()
 
         private int Stem(char[] term, int length)
         {
-            // LUCENENET specific (#1072): guard against a zero-length term. When
-            // minimumKatakanaLength == 0 a zero-length token (e.g. the single empty token a
-            // KeywordTokenizer emits for empty input) passes the length check below, IsKatakana
-            // vacuously returns true, and the term[length - 1] access below reads term[-1].
-            // Upstream Java has the same latent term[-1] read, but its TestRandomChains never
-            // exercises the kuromoji filters (separate module), so it never surfaces there.
-            // There is nothing to stem in a zero-length term, so return it unchanged.
-            if (length == 0)
-            {
-                return length;
-            }
-
             if (length < minimumKatakanaLength)
             {
                 return length;

src/Lucene.Net.Tests.Analysis.Kuromoji/TestJapaneseKatakanaStemFilter.cs

@@ -101,25 +101,21 @@ public void TestEmptyTerm()
         /// <summary>
         /// LUCENENET-specific regression test for <a href="https://github.com/apache/lucenenet/issues/1072">#1072</a>.
         /// <para/>
-        /// With a <c>minimumLength</c> of <c>0</c>, a zero-length token (such as the single empty token a
-        /// <see cref="KeywordTokenizer"/> emits for empty input) would skip the length check in <c>Stem()</c>,
-        /// <c>IsKatakana</c> would vacuously return <c>true</c>, and the <c>term[length - 1]</c> access would
-        /// read <c>term[-1]</c>, throwing <see cref="IndexOutOfRangeException"/>. This was a residual
-        /// <c>TestRandomChains</c> failure reported on PR #1348 (e.g. seed
-        /// <c>0x951afd480395f9b7:0x63fc16274945f1a3</c>); upstream Java has the same latent read but never
-        /// exercises the kuromoji filters from its own random-chains test.
+        /// Verifies the LUCENE-10352 guard: the constructor must reject a <c>minimumLength</c> less than
+        /// <c>1</c>. A <c>minimumLength</c> of <c>0</c> would let a zero-length token (such as the single empty
+        /// token a <see cref="KeywordTokenizer"/> emits for empty input) skip the length check in <c>Stem()</c>,
+        /// after which the <c>term[length - 1]</c> access reads <c>term[-1]</c> and throws. This surfaced as a
+        /// residual <c>TestRandomChains</c> failure reported on PR #1348 (e.g. seed
+        /// <c>0x951afd480395f9b7:0x63fc16274945f1a3</c>).
         /// </summary>
         [Test]
         [LuceneNetSpecific] // Issue #1072
-        public void TestEmptyTermWithZeroMinimumLengthDoesNotThrow()
+        public void TestMinimumLengthLessThanOneThrows()
         {
-            Analyzer a = Analyzer.NewAnonymous(createComponents: (fieldName, reader) =>
-            {
-                Tokenizer tokenizer = new KeywordTokenizer(reader);
-                return new TokenStreamComponents(tokenizer, new JapaneseKatakanaStemFilter(tokenizer, minimumLength: 0));
-            });
+            Tokenizer tokenizer = new KeywordTokenizer(new System.IO.StringReader(""));
 
-            CheckOneTerm(a, "", "");
+            Assert.Throws<ArgumentOutOfRangeException>(() => new JapaneseKatakanaStemFilter(tokenizer, minimumLength: 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => new JapaneseKatakanaStemFilter(tokenizer, minimumLength: -1));
         }
     }
 }