more tests

SimonCropp · SimonCropp · commit 5cc4e1263adc · 2026-04-14T13:17:50.000+10:00
diff --git a/src/Tests.ImageSharp/Tests.ImageSharp.csproj b/src/Tests.ImageSharp/Tests.ImageSharp.csproj
@@ -2,7 +2,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
-    <RootNamespace>Tests</RootNamespace>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="NUnit" />
diff --git a/src/Tests.Skia/Tests.Skia.csproj b/src/Tests.Skia/Tests.Skia.csproj
@@ -2,7 +2,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
-    <RootNamespace>Tests</RootNamespace>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="NUnit" />
diff --git a/src/Tests/PowerpointUnitTests.cs b/src/Tests/PowerpointUnitTests.cs
@@ -1,4 +1,3 @@
-using DocumentFormat.OpenXml;
 using DocumentFormat.OpenXml.Presentation;
 using A = DocumentFormat.OpenXml.Drawing;
 
@@ -70,7 +69,7 @@ public void GetPowerpointInfo_SlideWithNoText_TextIsNull()
     }
 
     [Test]
-    public void GetSlideText_EmptySlide_ReturnsEmpty()
+    public void AppendSlideText_EmptySlide_ReturnsFalse()
     {
         using var doc = CreateEmptyDoc();
         var slidePart = doc.PresentationPart!.AddNewPart<SlidePart>();
@@ -82,31 +81,36 @@ public void GetSlideText_EmptySlide_ReturnsEmpty()
                     new ApplicationNonVisualDrawingProperties()),
                 new GroupShapeProperties(new A.TransformGroup()))));
 
-        Assert.That(VerifyOpenXml.GetSlideText(slidePart), Is.EqualTo(string.Empty));
+        var builder = new System.Text.StringBuilder();
+        Assert.That(VerifyOpenXml.AppendSlideText(builder, slidePart), Is.False);
+        Assert.That(builder.Length, Is.Zero);
     }
 
     [Test]
-    public void GetSlideText_WithParagraphs()
+    public void AppendSlideText_WithParagraphs()
     {
         using var doc = CreateEmptyDoc();
         var presPart = doc.PresentationPart!;
         var slidePart = AddSlide(presPart, "Line1", "Line2");
-        var text = VerifyOpenXml.GetSlideText(slidePart);
+        var builder = new System.Text.StringBuilder();
+        Assert.That(VerifyOpenXml.AppendSlideText(builder, slidePart), Is.True);
+        var text = builder.ToString();
         Assert.That(text, Does.Contain("Line1"));
         Assert.That(text, Does.Contain("Line2"));
     }
 
     [Test]
-    public void GetSlideText_ParagraphWithNoText_SkippedFromOutput()
+    public void AppendSlideText_ParagraphWithNoText_SkippedFromOutput()
     {
         using var doc = CreateEmptyDoc();
         var presPart = doc.PresentationPart!;
         var slidePart = presPart.AddNewPart<SlidePart>();
         slidePart.Slide = BuildSlide(
             new A.Paragraph(),
             new A.Paragraph(new A.Run(new A.RunProperties(), new A.Text("Only"))));
-        var text = VerifyOpenXml.GetSlideText(slidePart);
-        Assert.That(text.TrimEnd(), Is.EqualTo("Only"));
+        var builder = new System.Text.StringBuilder();
+        VerifyOpenXml.AppendSlideText(builder, slidePart);
+        Assert.That(builder.ToString(), Is.EqualTo("Only"));
     }
 
     static PresentationDocument CreateEmptyDoc()
diff --git a/src/Tests/WordUnitTests.cs b/src/Tests/WordUnitTests.cs
@@ -89,29 +89,43 @@ public void GetWordDocumentText_WithTable()
     }
 
     [Test]
-    public void GetWordParagraphText_TextAndTab()
+    public void AppendWordParagraphText_TextAndTab()
     {
         var run = new Run(new WordText("Hi"), new TabChar());
-        Assert.That(VerifyOpenXml.GetWordParagraphText(new Paragraph(run)), Is.EqualTo("Hi\t"));
+        Assert.That(Render(new Paragraph(run)), Is.EqualTo("Hi\t"));
     }
 
     [Test]
-    public void GetWordParagraphText_PageBreak()
+    public void AppendWordParagraphText_PageBreak()
     {
         var run = new Run(new WordText("Before"), new Break { Type = BreakValues.Page });
-        var result = VerifyOpenXml.GetWordParagraphText(new Paragraph(run));
-        Assert.That(result, Does.Contain("--- Page Break ---"));
+        Assert.That(Render(new Paragraph(run)), Does.Contain("--- Page Break ---"));
     }
 
     [Test]
-    public void GetWordParagraphText_LineBreak()
+    public void AppendWordParagraphText_LineBreak()
     {
         var run = new Run(new WordText("A"), new Break());
-        var result = VerifyOpenXml.GetWordParagraphText(new Paragraph(run));
+        var result = Render(new Paragraph(run));
         Assert.That(result, Does.StartWith("A"));
         Assert.That(result, Does.Not.Contain("Page Break"));
     }
 
+    [Test]
+    public void AppendWordParagraphText_Empty_ReturnsFalse()
+    {
+        var builder = new System.Text.StringBuilder();
+        Assert.That(VerifyOpenXml.AppendWordParagraphText(builder, new Paragraph()), Is.False);
+        Assert.That(builder.Length, Is.Zero);
+    }
+
+    static string Render(Paragraph paragraph)
+    {
+        var builder = new System.Text.StringBuilder();
+        VerifyOpenXml.AppendWordParagraphText(builder, paragraph);
+        return builder.ToString();
+    }
+
     [Test]
     public void GetWordDocumentFonts_NoFontTablePart_ReturnsNulls()
     {
diff --git a/src/Verify.OpenXml/VerifyOpenXml_Powerpoint.cs b/src/Verify.OpenXml/VerifyOpenXml_Powerpoint.cs
@@ -36,25 +36,32 @@ static ConversionResult ConvertPowerpoint(PresentationDocument document, IReadOn
     internal static PowerpointInfo GetPowerpointInfo(PresentationDocument document)
     {
         var presentationPart = document.PresentationPart;
-        var slideTexts = new List<string>();
+        var builder = new StringBuilder();
+        var slideCount = 0;
 
         if (presentationPart?.SlideParts != null)
         {
             foreach (var slidePart in presentationPart.SlideParts)
             {
-                var text = GetSlideText(slidePart);
-                if (!string.IsNullOrEmpty(text))
+                slideCount++;
+                var before = builder.Length;
+                if (before > 0)
                 {
-                    slideTexts.Add(text);
+                    builder.Append("\n---\n");
+                }
+
+                if (!AppendSlideText(builder, slidePart))
+                {
+                    builder.Length = before;
                 }
             }
         }
 
         return new()
         {
             Properties = GetPowerpointProperties(document),
-            SlideCount = presentationPart?.SlideParts.Count() ?? 0,
-            Text = slideTexts.Count > 0 ? string.Join("\n---\n", slideTexts) : null
+            SlideCount = slideCount,
+            Text = builder.Length > 0 ? builder.ToString() : null
         };
     }
 
@@ -76,31 +83,37 @@ internal static PowerpointInfo GetPowerpointInfo(PresentationDocument document)
         return properties.Count > 0 ? properties : null;
     }
 
-    internal static string GetSlideText(SlidePart slidePart)
+    internal static bool AppendSlideText(StringBuilder builder, SlidePart slidePart)
     {
-        var builder = new StringBuilder();
-
         var slide = slidePart.Slide;
         if (slide == null)
         {
-            return string.Empty;
+            return false;
         }
 
+        var startLength = builder.Length;
+
         foreach (var paragraph in slide.Descendants<PParagraph>())
         {
-            var paragraphText = new StringBuilder();
+            var paragraphStart = builder.Length;
             foreach (var text in paragraph.Descendants<PText>())
             {
-                paragraphText.Append(text.Text);
+                builder.Append(text.Text);
             }
 
-            if (paragraphText.Length > 0)
+            if (builder.Length > paragraphStart)
             {
-                builder.AppendLine(paragraphText.ToString());
+                builder.AppendLine();
             }
         }
 
-        return builder.ToString().TrimEnd();
+        if (builder.Length == startLength)
+        {
+            return false;
+        }
+
+        builder.TrimEnd();
+        return builder.Length > startLength;
     }
 }
 
diff --git a/src/Verify.OpenXml/VerifyOpenXml_Word.cs b/src/Verify.OpenXml/VerifyOpenXml_Word.cs
@@ -206,37 +206,37 @@ static void AddPropertyIfNotEmpty(Dictionary<string, object?> properties, string
         var builder = new StringBuilder();
         foreach (var paragraph in body.Elements<Paragraph>())
         {
-            var paragraphText = GetWordParagraphText(paragraph);
-            if (!string.IsNullOrEmpty(paragraphText))
+            if (AppendWordParagraphText(builder, paragraph))
             {
-                builder.AppendLine(paragraphText);
+                builder.AppendLine();
             }
         }
 
-        // Also get text from tables
         foreach (var table in body.Elements<WordTable>())
         {
             foreach (var row in table.Elements<TableRow>())
             {
-                var rowTexts = new List<string>();
+                var firstCell = true;
+                var anyCell = false;
                 foreach (var cell in row.Elements<TableCell>())
                 {
-                    var cellText = new StringBuilder();
-                    foreach (var paragraph in cell.Elements<Paragraph>())
+                    if (!firstCell)
                     {
-                        var paragraphText = GetWordParagraphText(paragraph);
-                        if (!string.IsNullOrEmpty(paragraphText))
-                        {
-                            cellText.Append(paragraphText);
-                        }
+                        builder.Append('\t');
                     }
 
-                    rowTexts.Add(cellText.ToString());
+                    firstCell = false;
+                    anyCell = true;
+
+                    foreach (var paragraph in cell.Elements<Paragraph>())
+                    {
+                        AppendWordParagraphText(builder, paragraph);
+                    }
                 }
 
-                if (rowTexts.Count > 0)
+                if (anyCell)
                 {
-                    builder.AppendLine(string.Join('\t', rowTexts));
+                    builder.AppendLine();
                 }
             }
         }
@@ -250,9 +250,9 @@ static void AddPropertyIfNotEmpty(Dictionary<string, object?> properties, string
         return string.IsNullOrEmpty(result) ? null : result;
     }
 
-    internal static string GetWordParagraphText(Paragraph paragraph)
+    internal static bool AppendWordParagraphText(StringBuilder builder, Paragraph paragraph)
     {
-        var builder = new StringBuilder();
+        var startLength = builder.Length;
 
         foreach (var run in paragraph.Elements<WordRun>())
         {
@@ -261,13 +261,11 @@ internal static string GetWordParagraphText(Paragraph paragraph)
                 builder.Append(text.Text);
             }
 
-            // Handle tabs
             foreach (var _ in run.Elements<TabChar>())
             {
                 builder.Append('\t');
             }
 
-            // Handle breaks
             foreach (var wordBreak in run.Elements<WordBreak>())
             {
                 if (wordBreak.Type?.Value == BreakValues.Page)
@@ -282,6 +280,6 @@ internal static string GetWordParagraphText(Paragraph paragraph)
             }
         }
 
-        return builder.ToString();
+        return builder.Length > startLength;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -36,25 +36,32 @@ static ConversionResult ConvertPowerpoint(PresentationDocument document, IReadOn`
`36`	`36`	`internal static PowerpointInfo GetPowerpointInfo(PresentationDocument document)`
`37`	`37`	`{`
`38`	`38`	`var presentationPart = document.PresentationPart;`
`39`		`- var slideTexts = new List<string>();`
	`39`	`+ var builder = new StringBuilder();`
	`40`	`+ var slideCount = 0;`
`40`	`41`
`41`	`42`	`if (presentationPart?.SlideParts != null)`
`42`	`43`	`{`
`43`	`44`	`foreach (var slidePart in presentationPart.SlideParts)`
`44`	`45`	`{`
`45`		`- var text = GetSlideText(slidePart);`
`46`		`- if (!string.IsNullOrEmpty(text))`
	`46`	`+ slideCount++;`
	`47`	`+ var before = builder.Length;`
	`48`	`+ if (before > 0)`
`47`	`49`	`{`
`48`		`- slideTexts.Add(text);`
	`50`	`+ builder.Append("\n---\n");`
	`51`	`+ }`
	`52`	`+`
	`53`	`+ if (!AppendSlideText(builder, slidePart))`
	`54`	`+ {`
	`55`	`+ builder.Length = before;`
`49`	`56`	`}`
`50`	`57`	`}`
`51`	`58`	`}`
`52`	`59`
`53`	`60`	`return new()`
`54`	`61`	`{`
`55`	`62`	`Properties = GetPowerpointProperties(document),`
`56`		`- SlideCount = presentationPart?.SlideParts.Count() ?? 0,`
`57`		`- Text = slideTexts.Count > 0 ? string.Join("\n---\n", slideTexts) : null`
	`63`	`+ SlideCount = slideCount,`
	`64`	`+ Text = builder.Length > 0 ? builder.ToString() : null`
`58`	`65`	`};`
`59`	`66`	`}`
`60`	`67`
`@@ -76,31 +83,37 @@ internal static PowerpointInfo GetPowerpointInfo(PresentationDocument document)`
`76`	`83`	`return properties.Count > 0 ? properties : null;`
`77`	`84`	`}`
`78`	`85`
`79`		`- internal static string GetSlideText(SlidePart slidePart)`
	`86`	`+ internal static bool AppendSlideText(StringBuilder builder, SlidePart slidePart)`
`80`	`87`	`{`
`81`		`- var builder = new StringBuilder();`
`82`		`-`
`83`	`88`	`var slide = slidePart.Slide;`
`84`	`89`	`if (slide == null)`
`85`	`90`	`{`
`86`		`- return string.Empty;`
	`91`	`+ return false;`
`87`	`92`	`}`
`88`	`93`
	`94`	`+ var startLength = builder.Length;`
	`95`	`+`
`89`	`96`	`foreach (var paragraph in slide.Descendants<PParagraph>())`
`90`	`97`	`{`
`91`		`- var paragraphText = new StringBuilder();`
	`98`	`+ var paragraphStart = builder.Length;`
`92`	`99`	`foreach (var text in paragraph.Descendants<PText>())`
`93`	`100`	`{`
`94`		`- paragraphText.Append(text.Text);`
	`101`	`+ builder.Append(text.Text);`
`95`	`102`	`}`
`96`	`103`
`97`		`- if (paragraphText.Length > 0)`
	`104`	`+ if (builder.Length > paragraphStart)`
`98`	`105`	`{`
`99`		`- builder.AppendLine(paragraphText.ToString());`
	`106`	`+ builder.AppendLine();`
`100`	`107`	`}`
`101`	`108`	`}`
`102`	`109`
`103`		`- return builder.ToString().TrimEnd();`
	`110`	`+ if (builder.Length == startLength)`
	`111`	`+ {`
	`112`	`+ return false;`
	`113`	`+ }`
	`114`	`+`
	`115`	`+ builder.TrimEnd();`
	`116`	`+ return builder.Length > startLength;`
`104`	`117`	`}`
`105`	`118`	`}`
`106`	`119`
Original file line number	Diff line number	Diff line change
`@@ -206,37 +206,37 @@ static void AddPropertyIfNotEmpty(Dictionary<string, object?> properties, string`
`206`	`206`	`var builder = new StringBuilder();`
`207`	`207`	`foreach (var paragraph in body.Elements<Paragraph>())`
`208`	`208`	`{`
`209`		`- var paragraphText = GetWordParagraphText(paragraph);`
`210`		`- if (!string.IsNullOrEmpty(paragraphText))`
	`209`	`+ if (AppendWordParagraphText(builder, paragraph))`
`211`	`210`	`{`
`212`		`- builder.AppendLine(paragraphText);`
	`211`	`+ builder.AppendLine();`
`213`	`212`	`}`
`214`	`213`	`}`
`215`	`214`
`216`		`- // Also get text from tables`
`217`	`215`	`foreach (var table in body.Elements<WordTable>())`
`218`	`216`	`{`
`219`	`217`	`foreach (var row in table.Elements<TableRow>())`
`220`	`218`	`{`
`221`		`- var rowTexts = new List<string>();`
	`219`	`+ var firstCell = true;`
	`220`	`+ var anyCell = false;`
`222`	`221`	`foreach (var cell in row.Elements<TableCell>())`
`223`	`222`	`{`
`224`		`- var cellText = new StringBuilder();`
`225`		`- foreach (var paragraph in cell.Elements<Paragraph>())`
	`223`	`+ if (!firstCell)`
`226`	`224`	`{`
`227`		`- var paragraphText = GetWordParagraphText(paragraph);`
`228`		`- if (!string.IsNullOrEmpty(paragraphText))`
`229`		`- {`
`230`		`- cellText.Append(paragraphText);`
`231`		`- }`
	`225`	`+ builder.Append('\t');`
`232`	`226`	`}`
`233`	`227`
`234`		`- rowTexts.Add(cellText.ToString());`
	`228`	`+ firstCell = false;`
	`229`	`+ anyCell = true;`
	`230`	`+`
	`231`	`+ foreach (var paragraph in cell.Elements<Paragraph>())`
	`232`	`+ {`
	`233`	`+ AppendWordParagraphText(builder, paragraph);`
	`234`	`+ }`
`235`	`235`	`}`
`236`	`236`
`237`		`- if (rowTexts.Count > 0)`
	`237`	`+ if (anyCell)`
`238`	`238`	`{`
`239`		`- builder.AppendLine(string.Join('\t', rowTexts));`
	`239`	`+ builder.AppendLine();`
`240`	`240`	`}`
`241`	`241`	`}`
`242`	`242`	`}`
`@@ -250,9 +250,9 @@ static void AddPropertyIfNotEmpty(Dictionary<string, object?> properties, string`
`250`	`250`	`return string.IsNullOrEmpty(result) ? null : result;`
`251`	`251`	`}`
`252`	`252`
`253`		`- internal static string GetWordParagraphText(Paragraph paragraph)`
	`253`	`+ internal static bool AppendWordParagraphText(StringBuilder builder, Paragraph paragraph)`
`254`	`254`	`{`
`255`		`- var builder = new StringBuilder();`
	`255`	`+ var startLength = builder.Length;`
`256`	`256`
`257`	`257`	`foreach (var run in paragraph.Elements<WordRun>())`
`258`	`258`	`{`
`@@ -261,13 +261,11 @@ internal static string GetWordParagraphText(Paragraph paragraph)`
`261`	`261`	`builder.Append(text.Text);`
`262`	`262`	`}`
`263`	`263`
`264`		`- // Handle tabs`
`265`	`264`	`foreach (var _ in run.Elements<TabChar>())`
`266`	`265`	`{`
`267`	`266`	`builder.Append('\t');`
`268`	`267`	`}`
`269`	`268`
`270`		`- // Handle breaks`
`271`	`269`	`foreach (var wordBreak in run.Elements<WordBreak>())`
`272`	`270`	`{`
`273`	`271`	`if (wordBreak.Type?.Value == BreakValues.Page)`
`@@ -282,6 +280,6 @@ internal static string GetWordParagraphText(Paragraph paragraph)`
`282`	`280`	`}`
`283`	`281`	`}`
`284`	`282`
`285`		`- return builder.ToString();`
	`283`	`+ return builder.Length > startLength;`
`286`	`284`	`}`
`287`	`285`	`}`