wip

Author: swmal

src/EPPlus.Fonts.OpenType.Tests/FallbackFonts/FontProviderTests.cs

@@ -0,0 +1,117 @@
+/*************************************************************************************************
+  Font Provider Unit Tests
+  Tests for automatic emoji fallback functionality
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.TextShaping;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Linq;
+
+namespace EPPlus.Fonts.OpenType.Tests.FallbackFonts
+{
+    [TestClass]
+    public class FontProviderTests : FontTestBase
+    {
+        public override TestContext? TestContext { get; set; }
+
+        private OpenTypeFont _robotoFont;
+
+        [TestInitialize]
+        public void TestSetup()
+        {
+            _robotoFont = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+        }
+
+        [TestMethod]
+        public void DefaultFontProvider_EmojiGlyph_ShouldUseFallbackFont()
+        {
+            // Arrange
+            var shaper = new TextShaper(_robotoFont);
+
+            // Act
+            var shaped = shaper.Shape("😀");
+            var usedFonts = shaper.GetUsedFonts().ToList();
+
+            // Assert
+            Assert.AreEqual(1, shaped.Glyphs.Length, "Should have 1 glyph");
+            Assert.AreNotEqual((ushort)0, shaped.Glyphs[0].GlyphId, "Emoji should not be .notdef");
+            Assert.AreEqual((byte)0, shaped.Glyphs[0].FontId, "Emoji is the only font used (FontId=0)");
+
+            // Verify it's NOT the primary font
+            Assert.AreEqual(1, usedFonts.Count, "Should only use one font (emoji fallback)");
+            Assert.AreNotEqual(_robotoFont, usedFonts[0], "Should be emoji font, not Roboto");
+        }
+
+        [TestMethod]
+        public void DefaultFontProvider_LatinText_ShouldUsePrimaryFont()
+        {
+            // Arrange
+            var shaper = new TextShaper(_robotoFont);
+
+            // Act
+            var shaped = shaper.Shape("Hello World");
+
+            // Assert
+            foreach (var glyph in shaped.Glyphs)
+            {
+                Assert.AreEqual((byte)0, glyph.FontId, "All glyphs should be from primary font");
+            }
+        }
+
+        [TestMethod]
+        public void DefaultFontProvider_MixedTextAndEmoji_ShouldUseMultipleFonts()
+        {
+            // Arrange
+            var shaper = new TextShaper(_robotoFont);
+
+            // Act
+            var shaped = shaper.Shape("Hello 😀 World");
+            var usedFonts = shaper.GetUsedFonts().ToList();
+
+            // Assert
+            Assert.AreEqual(2, usedFonts.Count, "Should use 2 fonts (primary + emoji fallback)");
+            Assert.AreEqual(_robotoFont, usedFonts[0], "First font should be primary");
+            Assert.AreNotEqual(_robotoFont, usedFonts[1], "Second font should be emoji fallback");
+        }
+
+        [TestMethod]
+        public void TextShaper_SurrogatePair_ShouldMapToSingleGlyph()
+        {
+            // Arrange
+            var shaper = new TextShaper(_robotoFont);
+            string text = "😀"; // U+1F600 = 2 chars in UTF-16
+
+            // Act
+            var shaped = shaper.Shape(text);
+
+            // Assert
+            Assert.AreEqual(2, text.Length, "Emoji should be 2 chars in .NET");
+            Assert.AreEqual(1, shaped.Glyphs.Length, "Should map to 1 glyph");
+            Assert.AreEqual((byte)2, shaped.Glyphs[0].CharCount, "Glyph should span 2 chars");
+            Assert.AreEqual((ushort)0, shaped.Glyphs[0].ClusterIndex, "Should start at char 0");
+        }
+
+        [TestMethod]
+        public void TextShaper_MultipleEmoji_ShouldMapCorrectly()
+        {
+            // Arrange
+            var shaper = new TextShaper(_robotoFont);
+            string text = "😀😁😂"; // 3 emoji = 6 chars in UTF-16
+
+            // Act
+            var shaped = shaper.Shape(text);
+
+            // Assert
+            Assert.AreEqual(6, text.Length, "3 emoji = 6 chars");
+            Assert.AreEqual(3, shaped.Glyphs.Length, "Should map to 3 glyphs");
+
+            Assert.AreEqual((ushort)0, shaped.Glyphs[0].ClusterIndex, "First emoji at char 0");
+            Assert.AreEqual((byte)2, shaped.Glyphs[0].CharCount, "First emoji spans 2 chars");
+
+            Assert.AreEqual((ushort)2, shaped.Glyphs[1].ClusterIndex, "Second emoji at char 2");
+            Assert.AreEqual((byte)2, shaped.Glyphs[1].CharCount, "Second emoji spans 2 chars");
+
+            Assert.AreEqual((ushort)4, shaped.Glyphs[2].ClusterIndex, "Third emoji at char 4");
+            Assert.AreEqual((byte)2, shaped.Glyphs[2].CharCount, "Third emoji spans 2 chars");
+        }
+    }
+}

src/EPPlus.Fonts.OpenType.Tests/Integration/MeasurerComparisonTests.cs

@@ -119,7 +119,7 @@ public void Compare_MeasureMultiLineText_NewImplementationFixesBugs()
                 Debug.WriteLine($"Line '{line}': {lineResult.Width}");
             }
 
-            double expectedHeight = shaper.GetLineHeightInPoints(11.0) * lines.Length;
+            double expectedHeight = shaper.GetLineHeightInPoints(11.0f) * lines.Length;
 
             // Assert
             Debug.WriteLine("");
@@ -164,7 +164,7 @@ public void Compare_GetSingleLineSpacing_ShouldMatch()
 
             // Act
             var oldSpacing = oldMeasurer.GetSingleLineSpacing();
-            var newSpacing = shaper.GetLineHeightInPoints(11.0);
+            var newSpacing = shaper.GetLineHeightInPoints(11.0f);
 
             // Assert
             Debug.WriteLine($"Old Spacing: {oldSpacing}, New Spacing: {newSpacing}");
@@ -185,7 +185,7 @@ public void Compare_GetBaseLine_ShouldMatch()
 
             // Act
             var oldBaseline = oldMeasurer.GetBaseLine();
-            var newBaseline = shaper.GetBaseLineInPoints(11.0);
+            var newBaseline = shaper.GetBaseLineInPoints(11.0f);
 
             // Assert
             Debug.WriteLine($"Old Baseline: {oldBaseline}, New Baseline: {newBaseline}");

src/EPPlus.Fonts.OpenType.Tests/TextShaping/MarkToBaseTests.cs

@@ -21,14 +21,19 @@ public void MarkToBaseTest()
             var shaper = new TextShaper(font);
 
             string test = "A\u0302\u0309";
-            var shaped = shaper.Shape(test, ShapingOptions.Full);
-
-            Debug.WriteLine("Glyphs för 'Ẩn ặ':");
-            foreach (var g in shaped.Glyphs)
+            // Lägg till lite synchronization för att verifiera
+            lock (typeof(MarkToBaseTests))
             {
-                Debug.WriteLine($"GID={g.GlyphId,-4} XAdv={g.XAdvance,-5} YOff={g.YOffset,-4}");
+                var shaped = shaper.Shape(test, ShapingOptions.Full);
+
+                foreach (var g in shaped.Glyphs)
+                {
+                    Debug.WriteLine($"GID={g.GlyphId,-4} XAdv={g.XAdvance,-5} YOff={g.YOffset,-4}");
+                }
+
+                Assert.IsTrue(shaped.Glyphs.Any(x => x.YOffset > 0),
+                    $"Expected YOffset > 0. Got: {string.Join(", ", shaped.Glyphs.Select(g => $"Y={g.YOffset}"))}");
             }
-            Assert.IsTrue(shaped.Glyphs.Any(x => x.YOffset > 0));
         }
     }
 }

src/EPPlus.Fonts.OpenType/EmbeddedFonts.cs

@@ -52,9 +52,55 @@ private static OpenTypeFont LoadCached(string resourceName)
             }
         }
 
+        /// <summary>
+        /// Reads all bytes from a stream into a byte array.
+        /// .NET 3.5 compatible (no CopyTo available).
+        /// </summary>
         private static byte[] ReadStreamFully(Stream stream)
         {
-            throw new NotImplementedException();
+            if (stream == null)
+                throw new ArgumentNullException("stream");
+
+            // Try to use stream length if available (e.g., MemoryStream, FileStream)
+            if (stream.CanSeek)
+            {
+                long length = stream.Length - stream.Position;
+                if (length > int.MaxValue)
+                    throw new InvalidOperationException("Stream is too large to read into memory");
+
+                byte[] buffer = new byte[(int)length];
+                int offset = 0;
+                int remaining = (int)length;
+
+                while (remaining > 0)
+                {
+                    int read = stream.Read(buffer, offset, remaining);
+                    if (read <= 0)
+                        throw new EndOfStreamException("Stream ended before reading all bytes");
+
+                    offset += read;
+                    remaining -= read;
+                }
+
+                return buffer;
+            }
+            else
+            {
+                // Non-seekable stream (rare for embedded resources, but handle it)
+                // Use MemoryStream to accumulate bytes
+                using (var ms = new MemoryStream())
+                {
+                    byte[] buffer = new byte[8192]; // 8KB buffer
+                    int bytesRead;
+
+                    while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0)
+                    {
+                        ms.Write(buffer, 0, bytesRead);
+                    }
+
+                    return ms.ToArray();
+                }
+            }
         }
     }
 }

src/EPPlus.Fonts.OpenType/Integration/TextLayoutEngine.cs

@@ -63,17 +63,17 @@ public TextLayoutEngine(
             _spaceWidthCache = new Dictionary<float, double>();
         }
 
-        public double GetLineHeightInPoints(double fontSize)
+        public double GetLineHeightInPoints(float fontSize)
         {
             return _shaper.GetLineHeightInPoints(fontSize);
         }
 
-        public double GetBaseLineInPoints(double fontSize)
+        public double GetBaseLineInPoints(float fontSize)
         {
             return _shaper.GetBaseLineInPoints(fontSize);
         }
 
-        public double GetDescentInPoints(double fontSize)
+        public double GetDescentInPoints(float fontSize)
         {
             return _shaper.GetDescentInPoints(fontSize);
         }