fix: guard UnicodeText draw indexing

Author: agneszitte

src/Uno.UI.RuntimeTests/Tests/Windows_UI_Xaml_Controls/Given_TextBlock.cs

@@ -739,6 +739,66 @@ public async Task When_FontFamily_Changed(string font)
 			Assert.AreNotEqual(originalSize, SUT.DesiredSize);
 		}
 
+		[TestMethod]
+		[PlatformCondition(ConditionMode.Include, RuntimeTestPlatforms.Skia)]
+		public async Task When_TextBlock_With_Unpaired_Surrogate_Renders()
+		{
+			if (!ApiInformation.IsTypePresent("Microsoft.UI.Xaml.Media.Imaging.RenderTargetBitmap, Uno.UI"))
+			{
+				Assert.Inconclusive();
+			}
+
+			var text = "LTR \uD800 RTL שלום";
+			var sut = new TextBlock
+			{
+				Text = text,
+				TextWrapping = TextWrapping.Wrap
+			};
+			sut.TextHighlighters.Add(new TextHighlighter
+			{
+				Ranges =
+				{
+					new TextRange { StartIndex = 0, Length = text.Length }
+				}
+			});
+
+			var root = new Border
+			{
+				Width = 240,
+				Height = 120,
+				Child = sut
+			};
+
+			await UITestHelper.Load(root);
+			await UITestHelper.ScreenShot(root);
+		}
+
+		[TestMethod]
+		[PlatformCondition(ConditionMode.Include, RuntimeTestPlatforms.Skia)]
+		public async Task When_TextBlock_With_Unpaired_Surrogate_And_No_Highlighter_Renders()
+		{
+			if (!ApiInformation.IsTypePresent("Microsoft.UI.Xaml.Media.Imaging.RenderTargetBitmap, Uno.UI"))
+			{
+				Assert.Inconclusive();
+			}
+
+			var sut = new TextBlock
+			{
+				Text = "LTR \uD800 RTL שלום",
+				TextWrapping = TextWrapping.Wrap
+			};
+
+			var root = new Border
+			{
+				Width = 240,
+				Height = 120,
+				Child = sut
+			};
+
+			await UITestHelper.Load(root);
+			await UITestHelper.ScreenShot(root);
+		}
+
 		[TestMethod]
 #if !__ANDROID__
 		[Ignore("Android-only test for AndroidAssets backward compatibility")]

src/Uno.UI.Tests/Windows_UI_XAML_Controls/TextBlockTests/Given_TextBlock.cs

@@ -9,6 +9,7 @@
 using Microsoft.UI.Xaml.Controls;
 using System.Drawing;
 using Microsoft.UI.Xaml.Media;
+using Windows.Foundation;
 
 namespace Uno.UI.Tests.Windows_UI_XAML_Controls.TextBlockTests
 {
@@ -51,6 +52,55 @@ public void When_Changing_Foreground_Property()
 		}
 #endif
 
+		[TestMethod]
+		public void When_Text_Has_Unpaired_Surrogate_Does_Not_Throw()
+		{
+			var tb = new TextBlock
+			{
+				Text = "A\uD800B\uDC00"
+			};
+
+			tb.Measure(new Size(300, 80));
+		}
+
+		[TestMethod]
+		public void When_Text_Has_Unpaired_Surrogate_With_Highlighter_Does_Not_Throw()
+		{
+			var tb = new TextBlock
+			{
+				Text = "A\uD800B\uDC00"
+			};
+
+			tb.TextHighlighters.Add(new TextHighlighter
+			{
+				Ranges =
+				{
+					new TextRange { StartIndex = 0, Length = tb.Text.Length }
+				}
+			});
+
+			tb.Measure(new Size(300, 80));
+		}
+
+		[TestMethod]
+		public void When_Highlighter_Range_Exceeds_Text_Does_Not_Throw()
+		{
+			var tb = new TextBlock
+			{
+				Text = "abc"
+			};
+
+			tb.TextHighlighters.Add(new TextHighlighter
+			{
+				Ranges =
+				{
+					new TextRange { StartIndex = 0, Length = 999 }
+				}
+			});
+
+			tb.Measure(new Size(300, 80));
+		}
+
 		[TestMethod]
 		public void When_LineBreak_SurroundingWhiteSpace()
 		{

src/Uno.UI/UI/Xaml/Documents/UnicodeText.skia.cs

@@ -197,7 +197,7 @@ internal unsafe UnicodeText(
 			}
 		}
 
-		_text = stringBuilder.ToString();
+		_text = SanitizeText(stringBuilder.ToString());
 		if (_text.Length == 0)
 		{
 			_lines = [];
@@ -230,7 +230,7 @@ internal unsafe UnicodeText(
 			Array.Fill(embeddingLevels, (byte)level, start, count);
 		}
 
-		using var _ = ICU.CreateBiDiAndSetPara(_text, 0, _text.Length, flowDirection is FlowDirection.RightToLeft ? UBIDI_DEFAULT_RTL : UBIDI_DEFAULT_LTR, out var bidi, embeddingLevels);
+		using var _ = CreateBiDiOrFallback(_text, flowDirection, embeddingLevels, out var bidi);
 		var runCount = ICU.GetMethod<ICU.ubidi_countRuns>()(bidi, out var countRunsErrorCode);
 		ICU.CheckErrorCode<ICU.ubidi_countRuns>(countRunsErrorCode);
 		_rtl = ICU.GetMethod<ICU.ubidi_getParaLevel>()(bidi) is UBIDI_RTL;
@@ -837,39 +837,63 @@ public void Draw(in Visual.PaintingSession session,
 		var wordBoundariesIndex = 0;
 		var highlighterSlices = highlighterSlicer.GetSegments();
 		var highlighterIndex = 0;
+		var fallbackHighlight = (background: (CompositionBrush?)null, foreground: (Brush)_blackBrush);
 		for (var clusterIndex = 0; clusterIndex < _clustersInLogicalOrder.Count; clusterIndex++)
 		{
 			var cluster = _clustersInLogicalOrder[clusterIndex];
-			while (highlighterSlices[highlighterIndex].End <= cluster.Value.start)
+			RangeSlicer<(CompositionBrush? background, Brush foreground)>.Segment? highlighter = null;
+			if (highlighterSlices.Count > 0)
 			{
-				highlighterIndex++;
-			}
+				while (highlighterIndex + 1 < highlighterSlices.Count && highlighterSlices[highlighterIndex].End <= cluster.Value.start)
+				{
+					highlighterIndex++;
+				}
 
-			var highlighter = highlighterSlices[highlighterIndex];
+				highlighter = highlighterSlices[highlighterIndex];
+			}
 
-			while (_runBreaks[runBreakIndex].end <= cluster.Value.start)
+			if (_runBreaks.Count > 0)
 			{
-				runBreakIndex++;
+				while (runBreakIndex + 1 < _runBreaks.Count && _runBreaks[runBreakIndex].end <= cluster.Value.start)
+				{
+					runBreakIndex++;
+				}
 			}
 
-			while (_wordBoundaries[wordBoundariesIndex] <= cluster.Value.start)
+			if (_wordBoundaries.Count > 0)
 			{
-				wordBoundariesIndex++;
+				while (wordBoundariesIndex + 1 < _wordBoundaries.Count && _wordBoundaries[wordBoundariesIndex] <= cluster.Value.start)
+				{
+					wordBoundariesIndex++;
+				}
 			}
 
 			var lineIndex = cluster.Value.lineIndex;
+			if ((uint)lineIndex >= (uint)_lines.Count || (uint)lineIndex >= (uint)_xyTable.Count)
+			{
+				continue;
+			}
+
+			var lineMetrics = _xyTable[lineIndex];
+			if (cluster.Value.indexInLine > 0 && cluster.Value.indexInLine - 1 >= lineMetrics.prefixSummedWidths.Count)
+			{
+				continue;
+			}
+
 			var line = _lines[lineIndex];
-			var y = _xyTable[lineIndex].prefixSummedHeight - line.lineHeight;
+			var y = lineMetrics.prefixSummedHeight - line.lineHeight;
 			var unalignedX = cluster.Value.indexInLine == 0
 				? 0
-				: _xyTable[lineIndex].prefixSummedWidths[cluster.Value.indexInLine - 1].sumUntilAfterCluster;
+				: lineMetrics.prefixSummedWidths[cluster.Value.indexInLine - 1].sumUntilAfterCluster;
 			var alignmentOffset = GetAlignmentOffsetForLine(line);
 			var positionAcc = new SKPoint(unalignedX + alignmentOffset, y + line.baselineOffset);
 			var fontDetails = cluster.Value.fontDetails;
 
 			if (!cluster.Value.containsTab)
 			{
-				var color = BrushToColor(highlighter.Value.foreground is { } h ? h : _runBreaks[runBreakIndex].foreground, session.Opacity);
+				var runForeground = _runBreaks.Count > 0 ? _runBreaks[runBreakIndex].foreground : _blackBrush;
+				var highlightValue = highlighter?.Value ?? fallbackHighlight;
+				var color = BrushToColor(highlightValue.foreground is { } h ? h : runForeground, session.Opacity);
 				if (!_colorToFontToGlyphs.TryGetValue(color, out var fontToGlyphs))
 				{
 					_colorToFontToGlyphs[color] = fontToGlyphs = new Dictionary<SKFont, (List<ushort> glyphs, List<SKPoint> positions)>();
@@ -896,9 +920,9 @@ public void Draw(in Visual.PaintingSession session,
 			}
 
 			var backgroundRect = new SKRect(unalignedX + alignmentOffset, y, unalignedX + alignmentOffset + cluster.Value.width, y + line.lineHeight);
-			highlighter.Value.background?.Paint(session.Canvas, session.Opacity, backgroundRect);
+			(highlighter?.Value ?? fallbackHighlight).background?.Paint(session.Canvas, session.Opacity, backgroundRect);
 
-			if (_corrections?[wordBoundariesIndex] is { } correction)
+			if (_corrections is { } corrections && _wordBoundaries.Count > 0 && wordBoundariesIndex < corrections.Count && corrections[wordBoundariesIndex] is { } correction)
 			{
 				var correctionIndexBase = wordBoundariesIndex == 0 ? 0 : _wordBoundaries[wordBoundariesIndex - 1];
 				if (correctionIndexBase + correction.correctionStart <= cluster.Value.start && correctionIndexBase + correction.correctionEnd >= cluster.Value.end)
@@ -1275,10 +1299,79 @@ public int GetIndexAt(Point p, bool ignoreEndingNewLine, bool extendedSelection)
 
 	public bool IsBaseDirectionRightToLeft => _rtl;
 
+	private static string SanitizeText(string text)
+	{
+		var hasInvalid = false;
+		for (var i = 0; i < text.Length; i++)
+		{
+			var c = text[i];
+			if (char.IsHighSurrogate(c))
+			{
+				if (i + 1 < text.Length && char.IsLowSurrogate(text[i + 1]))
+				{
+					i++;
+					continue;
+				}
+				hasInvalid = true;
+				break;
+			}
+			if (char.IsLowSurrogate(c))
+			{
+				hasInvalid = true;
+				break;
+			}
+		}
+
+		if (!hasInvalid)
+		{
+			return text;
+		}
+
+		var chars = text.ToCharArray();
+		for (var i = 0; i < chars.Length; i++)
+		{
+			var c = chars[i];
+			if (char.IsHighSurrogate(c))
+			{
+				if (i + 1 < chars.Length && char.IsLowSurrogate(chars[i + 1]))
+				{
+					i++;
+					continue;
+				}
+				chars[i] = '\uFFFD';
+				continue;
+			}
+			if (char.IsLowSurrogate(c))
+			{
+				chars[i] = '\uFFFD';
+			}
+		}
+
+		return new string(chars);
+	}
+
+	private static DisposableStruct<IntPtr> CreateBiDiOrFallback(string text, FlowDirection flowDirection, byte[]? embeddingLevels, out IntPtr bidi)
+	{
+		var paraLevel = flowDirection is FlowDirection.RightToLeft ? UBIDI_DEFAULT_RTL : UBIDI_DEFAULT_LTR;
+		try
+		{
+			return ICU.CreateBiDiAndSetPara(text, 0, text.Length, paraLevel, out bidi, embeddingLevels);
+		}
+		catch (InvalidOperationException ex) when (embeddingLevels is not null)
+		{
+			typeof(UnicodeText).LogError()?.Error("ubidi_setPara failed with embedding levels; retrying without them.", ex);
+			return ICU.CreateBiDiAndSetPara(text, 0, text.Length, paraLevel, out bidi, embeddingLevels: null);
+		}
+	}
+
 	private static List<int> GetWords(string text)
 	{
 		var boundaries = new List<int>();
 		AppendBoundaries(/* Word */ 1, text, 0, boundaries);
+		if (boundaries.Count == 0)
+		{
+			return new List<int> { text.Length };
+		}
 		var ret = new List<int> { boundaries[0] };
 		for (var index = 1; index < boundaries.Count; index++)
 		{
@@ -1294,6 +1387,10 @@ private static List<int> GetWords(string text)
 			}
 			ret.Add(boundary);
 		}
+		if (ret[^1] != text.Length)
+		{
+			ret.Add(text.Length);
+		}
 
 		return ret;
 	}