Fix concurrent-write race in SafeTextWriterWrapper, apache#1246 (apache#1262)

* Fix concurrent-write race in SafeTextWriterWrapper, apache#1246

Wrap the inner TextWriter in TextWriter.Synchronized so that concurrent
writes from IndexSearcher executor threads to diagnostic info streams
(FieldCache, IndexWriter, SegmentInfos, CheckIndex) do not corrupt
non-thread-safe writers such as StringWriter. This matches the
thread-safety of Java's PrintStream, which synchronizes at the
println boundary.

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

* Add [TestFixture] and [LuceneNetSpecific] to TestSafeTextWriterWrapper

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

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: paulirwin

src/Lucene.Net.Tests/Support/IO/TestSafeTextWriterWrapper.cs

@@ -1,7 +1,9 @@
+using Lucene.Net.Attributes;
 using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.IO;
+using System.Threading.Tasks;
 
 namespace Lucene.Net.Support.IO
 {
@@ -22,6 +24,8 @@ namespace Lucene.Net.Support.IO
      * limitations under the License.
      */
 
+    [TestFixture]
+    [LuceneNetSpecific]
     public class TestSafeTextWriterWrapper : LuceneTestCase
     {
         [Test]
@@ -60,5 +64,33 @@ public void TestWriteLine()
             Assert.DoesNotThrow(() => safe.WriteLine("Testing"));
             Assert.DoesNotThrow(() => safe.WriteLine("Testing"));
         }
+
+        /// <summary>
+        /// LUCENENET specific. When <see cref="SafeTextWriterWrapper"/> wraps a
+        /// non-thread-safe <see cref="TextWriter"/> (such as <see cref="StringWriter"/>),
+        /// concurrent writes from multiple threads must not throw. This reproduces
+        /// https://github.com/apache/lucenenet/issues/1246 where the <see cref="FieldCache"/>
+        /// info stream was written concurrently from <see cref="Search.IndexSearcher"/>'s
+        /// executor threads, causing <see cref="ArgumentException"/> ("Destination is too
+        /// short") from <see cref="System.Text.StringBuilder"/>.
+        /// </summary>
+        [Test]
+        public void TestConcurrentWrites()
+        {
+            using var wrapped = new StringWriter();
+            using var safe = new SafeTextWriterWrapper(wrapped);
+
+            const int threadCount = 8;
+            const int iterationsPerThread = 2000;
+            const string line = "WARNING: new FieldCache insanity created. Details: some long-ish message for buffer growth.";
+
+            Parallel.For(0, threadCount, _ =>
+            {
+                for (int i = 0; i < iterationsPerThread; i++)
+                {
+                    safe.WriteLine(line);
+                }
+            });
+        }
     }
 }

src/Lucene.Net/Support/IO/SafeTextWriterWrapper.cs

@@ -44,7 +44,16 @@ internal class SafeTextWriterWrapper : TextWriter
 
         public SafeTextWriterWrapper(TextWriter textWriter)
         {
-            this.textWriter = textWriter ?? throw new ArgumentNullException(nameof(textWriter));
+            if (textWriter is null)
+                throw new ArgumentNullException(nameof(textWriter));
+
+            // LUCENENET specific: Wrap in a synchronized TextWriter so that concurrent
+            // writes from multiple threads (e.g., IndexSearcher executor threads writing
+            // to FieldCache.InfoStream) do not corrupt non-thread-safe writers such as
+            // StringWriter. This matches the thread-safety of Java's PrintStream, which
+            // synchronizes at the println boundary. See
+            // https://github.com/apache/lucenenet/issues/1246.
+            this.textWriter = TextWriter.Synchronized(textWriter);
         }
 
         public override Encoding Encoding => Run(() => textWriter.Encoding);