is normal white-space, so re-joining decoded words with single spaces reconstructs the
+ // original (collapsed) spacing exactly.
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap("Use for spaces"));
+ var c = LayoutHarness.FindById(root, "c")!;
+
+ Assert.AreEqual("Use for spaces", JoinWordsNormal(c));
+ }
+
+ [Ignore("Double-decoded (see class remarks): the already-tokenizer-decoded \"<html>\" gets decoded " +
+ "again by ParseToWords into literal \"\".")]
+ [TestMethod]
+ public void DoubleEscapedEntitiesInPreElement_RenderCorrectly()
+ {
+ // is white-space:pre via the UA default stylesheet - "<html>" has no whitespace
+ // at all, so it is a single word token, decoded in one pass with no join/spacing concerns.
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap("<html> "));
+ var p = LayoutHarness.FindById(root, "p")!;
+
+ Assert.AreEqual("<html>", JoinWordsPre(p));
+ }
+
+ [Ignore("The single-escaped portions (\"&\" -> \"&\") are fine, but the double-escaped \"&\" " +
+ "portion gets decoded twice (see class remarks), ending up as a plain \"&\" instead of the " +
+ "literal \"&\" this asserts.")]
+ [TestMethod]
+ public void MixedEntitiesInParagraph_RenderCorrectly()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap("A & B & C
"));
+ var p = LayoutHarness.FindById(root, "p")!;
+
+ Assert.AreEqual("A & B & C", JoinWordsNormal(p));
+ }
+
+ #endregion
+
+ #region CSS Content Strings
+
+ [TestMethod]
+ public void CssContentWithCssEscape_RendersLiterally()
+ {
+ const string html = "" +
+ "text
";
+ var (root, _) = LayoutHarness.Layout(html);
+ var p = LayoutHarness.FindById(root, "p")!;
+
+ var beforeBox = p.Boxes.FirstOrDefault(b => b.HtmlTag == null && b.Text != null);
+ Assert.IsNotNull(beforeBox);
+ Assert.AreEqual("&", beforeBox!.Text);
+ }
+
+ [Ignore("Requires ::before/::after pseudo-elements with a CSS content: property - this fork has no " +
+ "pseudo-element support at all (confirmed: no \"::before\"/\"::after\"/pseudo-element handling " +
+ "anywhere in Core, only :link/:hover pseudo-CLASSES are recognized).")]
+ [TestMethod]
+ public void CssContentWithCssEscapeInString_RendersLiterally()
+ {
+ const string html = "" +
+ "text
";
+ var (root, _) = LayoutHarness.Layout(html);
+ var p = LayoutHarness.FindById(root, "p")!;
+
+ var afterBox = p.Boxes.FirstOrDefault(b => b.HtmlTag == null && b.Text != null);
+ Assert.IsNotNull(afterBox);
+ Assert.IsTrue(afterBox!.Text!.Contains('<'));
+ Assert.IsTrue(afterBox.Text!.Contains('>'));
+ }
+
+ #endregion
+
+ #region Edge Cases
+
+ [Ignore("Double-decoded (see class remarks): \" \" is already literal \" \" by the time " +
+ "ParseToWords runs, and gets decoded again into a plain space.")]
+ [TestMethod]
+ public void WhitespacePreservation_WithEntities()
+ {
+ // white-space:pre preserves the two literal spaces between the entity and "test" as their own word
+ // token (see WhiteSpaceLayoutIntegrationTests' Pre_PreservesMultipleConsecutiveSpacesAsLiteralWord),
+ // so concatenating words with NO separator reconstructs the exact original spacing.
+ var (root, _) = LayoutHarness.Layout(
+ LayoutHarness.Wrap(" test
"));
+ var p = LayoutHarness.FindById(root, "p")!;
+
+ Assert.AreEqual(" test", JoinWordsPre(p));
+ }
+
+ [Ignore("Every double-escaped entity in this sentence gets decoded twice (see class remarks), so none of " +
+ "them survive as the literal entity references this asserts.")]
+ [TestMethod]
+ public void MultipleDoubleEscapedEntities_InSentence()
+ {
+ var (root, _) = LayoutHarness.Layout(
+ LayoutHarness.Wrap("Entities: <, >, &,
"));
+ var p = LayoutHarness.FindById(root, "p")!;
+
+ Assert.AreEqual("Entities: <, >, &, ", JoinWordsNormal(p));
+ }
+
+ [Ignore("Confirmed real (if convoluted) two-layer decode, empirically verified: raw \"&nbsp;\" -> " +
+ "HtmlKit's tokenizer decodes the FIRST \"&\" (greedy, single pass) to \"&\", leaving " +
+ "box.Text = \" \" (i.e. exactly the DoubleEscapedNbsp case's raw INPUT) -> " +
+ "ParseToWords's own DecodeHtml then decodes THAT down one more level to \" \", not the two " +
+ "literal levels (\" \") this asserts.")]
+ [TestMethod]
+ public void TripleEscapedEntity_RendersWithTwoLevels()
+ {
+ // &nbsp; -> the entity scan finds only the leading "&" (index 0..4) and decodes it to
+ // "&"; the remainder "amp;nbsp;" has no leading '&' left, so it stays literal - " ".
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap("&nbsp;
"));
+ var p = LayoutHarness.FindById(root, "p")!;
+
+ Assert.AreEqual(" ", JoinWordsNormal(p));
+ }
+
+ [TestMethod]
+ public void EntityInAttributeValue_DecodedCorrectly()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap("text
"));
+ var p = LayoutHarness.FindById(root, "p")!;
+
+ var title = p.HtmlTag?.TryGetAttribute("title", "");
+ Assert.AreEqual("A & B", title);
+ }
+
+ #endregion
+
+ // A block/inline CONTAINER box (e.g. , ) never carries its own Words directly - HtmlParser always
+ // puts text content into a separate anonymous CHILD CssBox (see HtmlParser.AddTextBox: it always creates a
+ // new child box and sets Text on THAT, never on the current container). So "p.Words" for a wrapping
+ // plain text is always empty; the real per-word decoded content lives on the descendant anonymous text
+ // box(es). AllWords flattens words from the box and every descendant, in document order, which is what
+ // these tests actually need to read back the decoded content.
+ private static IEnumerable AllWords(CssBox box) => LayoutHarness.Descendants(box).SelectMany(b => b.Words);
+
+ private static string JoinWordsNormal(CssBox box) => string.Join(" ", AllWords(box).Select(w => w.Text));
+
+ private static string JoinWordsPre(CssBox box) => string.Concat(AllWords(box).Select(w => w.Text));
+}
diff --git a/Source/Test/HtmlRenderer.IntegrationTest/Text/LinkPseudoClassIntegrationTests.cs b/Source/Test/HtmlRenderer.IntegrationTest/Text/LinkPseudoClassIntegrationTests.cs
new file mode 100644
index 000000000..b2f74ba8d
--- /dev/null
+++ b/Source/Test/HtmlRenderer.IntegrationTest/Text/LinkPseudoClassIntegrationTests.cs
@@ -0,0 +1,100 @@
+using HtmlRenderer.IntegrationTest.TestSupport;
+using TheArtOfDev.HtmlRenderer.Core.Dom;
+
+namespace HtmlRenderer.IntegrationTest.Text;
+
+///
+/// Verifies :link /:hover pseudo-class handling, and locks in the resulting gap that
+/// :visited /:active never match.
+///
+///
+///
+/// The CSS engine port replaced selector matching with a real implementation:
+/// DoesSelectorMatch(PseudoClassSelector, CssBox)
+/// only special-cases three pseudo-classes - :hover (matched structurally, always true; diverted to
+/// HtmlContainerInt.AddHoverBox instead of applied directly, so live mouse state stays out of the
+/// cascade), :root (matches the document's <html> element), and :link (matches
+/// box.IsClickable ) - everything else, including :visited /:active /:focus /
+/// :nth-child , falls through to return false , so a rule using them never matches anything.
+/// Unlike the old parser (which dropped the ENTIRE containing css block when it hit an unrecognized
+/// pseudo-class), the real engine parses the rule normally and simply never matches it - same observable
+/// outcome for :visited/:active here, via a completely different, real mechanism.
+///
+///
+/// :link specifically resolves through <a> element carrying an
+/// href attribute is clickable, matching CSS Selectors' own href-gated definition of :link
+/// directly - an <a> used only as a named anchor/target (no href) is correctly excluded.
+///
+///
+[DoNotParallelize]
+[TestClass]
+public sealed class LinkPseudoClassIntegrationTests
+{
+ // Anchors used to verify :link matching deliberately have no id/name attribute, matching PeachPDF's own
+ // setup, so FindByTag (not FindById) locates the anchor in these tests.
+
+ [TestMethod]
+ public void Link_MatchesAnchorWithHref()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap(
+ "link "));
+ var a = FindByTag(root, "a")!;
+
+ Assert.AreEqual("rgb(10, 20, 30)", a.Color);
+ }
+
+ [TestMethod]
+ public void Link_DoesNotMatchAnchorWithoutHref()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap(
+ "not a link "));
+ var a = FindByTag(root, "a")!;
+
+ Assert.AreNotEqual("rgb(10, 20, 30)", a.Color);
+ }
+
+ [TestMethod]
+ public void Link_DoesNotMatchNonAnchorElement()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap(
+ "not an anchor "));
+ var s = LayoutHarness.FindById(root, "s")!;
+
+ Assert.AreNotEqual("rgb(10, 20, 30)", s.Color);
+ }
+
+ [TestMethod]
+ public void Visited_NeverMatches_ByDesign()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap(
+ "link "));
+ var a = FindByTag(root, "a")!;
+
+ Assert.AreNotEqual("rgb(10, 20, 30)", a.Color);
+ }
+
+ [TestMethod]
+ public void Active_NeverMatches_ByDesign()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap(
+ "link "));
+ var a = FindByTag(root, "a")!;
+
+ Assert.AreNotEqual("rgb(10, 20, 30)", a.Color);
+ }
+
+ // ─── Helpers ─────────────────────────────────────────────────────────────
+
+ private static CssBox? FindByTag(CssBox box, string tag)
+ {
+ if (box.HtmlTag?.Name.Equals(tag, System.StringComparison.OrdinalIgnoreCase) == true)
+ return box;
+ foreach (var child in box.Boxes)
+ {
+ var found = FindByTag(child, tag);
+ if (found != null) return found;
+ }
+ return null;
+ }
+}
diff --git a/Source/Test/HtmlRenderer.IntegrationTest/Text/SmallCapsIntegrationTests.cs b/Source/Test/HtmlRenderer.IntegrationTest/Text/SmallCapsIntegrationTests.cs
new file mode 100644
index 000000000..2cabe0dd8
--- /dev/null
+++ b/Source/Test/HtmlRenderer.IntegrationTest/Text/SmallCapsIntegrationTests.cs
@@ -0,0 +1,182 @@
+using System.Linq;
+using HtmlRenderer.IntegrationTest.TestSupport;
+using TheArtOfDev.HtmlRenderer.Core.Dom;
+
+namespace HtmlRenderer.IntegrationTest.Text;
+
+///
+/// Regression coverage for font-variant: small-caps . Ported from PeachPDF's
+/// SmallCapsIntegrationTests , which covers a real small-caps synthesis pipeline (originally-lowercase
+/// runs upper-cased and re-measured/painted at a reduced size via DerivedStyle.ActualSmallCapsFont ,
+/// exposed on CssRectWord via FontSizeScale /SuppressWrapBefore , and a dedicated
+/// RecordingGraphics paint harness asserting DrawString call order/fonts).
+///
+///
+/// HTML-Renderer has none of that: font-variant IS parsed/stored as a plain string property
+/// (font-variant property and the font shorthand regex in
+/// CssParser.ParseFontProperty ), but a full-tree grep across CssLayoutEngine.cs and the
+/// font/paint code (ActualFont , RFontStyle construction) found zero non-storage read sites -
+/// it is a complete no-op beyond storage. There is also no font-variant-caps /all-small-caps
+/// support at all (not a recognized property name anywhere in this fork).
+///
+/// Confirmed by direct execution against the built assembly (not just source reading): laying out
+/// <b style="font-variant:small-caps">Hello</b> leaves the box with a single, unsplit
+/// "Hello" word - the same as with no font-variant at all.
+///
+///
+/// Because this fork has no equivalent of FontSizeScale /SmallCapsFontScale /
+/// ActualSmallCapsFont /SuppressWrapBefore (confirmed absent by grep - not merely unused, the
+/// members do not exist), PeachPDF's scale/measured-width/wrap-suppression/space-flag-on-fragment/paint-call
+/// tests have no faithful, compilable equivalent here and are intentionally not ported (porting a test file
+/// cannot invent new production API surface). What IS ported below is: (a) a parse/storage check, since that
+/// part of the property genuinely still works, and (b) the word-splitting expectation itself - the one
+/// observable signal shared by every PeachPDF case - both for real small-caps and for the (unsupported)
+/// all-small-caps spelling.
+///
+///
+// This fork's CssParser keeps a process-wide, non-thread-safe regex cache
+// (RegexParserUtils.GetRegex's static Dictionary) that SetHtml/DefaultCssData populate lazily on first use per
+// AppDomain; running HtmlContainerInt.SetHtml from more than one thread at once (as MSTestSettings.cs's
+// assembly-wide [Parallelize(Scope = ExecutionScope.MethodLevel)] does by default) can corrupt it and throw
+// "A concurrent update was performed on this collection". [DoNotParallelize] avoids tripping that pre-existing
+// library race rather than masking it.
+[DoNotParallelize]
+[TestClass]
+public sealed class SmallCapsIntegrationTests
+{
+ /// Finds the box that actually owns the word(s): text nodes get their own anonymous child
+ /// DomParser.CorrectTextBoxes ), so an element like
+ /// <b id="w">Hello</b> 's own box has an empty
+ private static CssBox FindWordsBox(CssBox root, string id)
+ {
+ var element = LayoutHarness.FindById(root, id)!;
+ if (element.Words.Count > 0) return element;
+
+ var wordsChild = element.Boxes.FirstOrDefault(b => b.Words.Count > 0);
+ Assert.IsNotNull(wordsChild, $"no descendant of #{id} owns any words");
+ return wordsChild!;
+ }
+
+ [TestMethod]
+ public void FontVariant_SmallCaps_StandaloneProperty_ParsesAndStores()
+ {
+ var (root, _) = LayoutHarness.Layout(
+ LayoutHarness.Wrap("Hello "));
+ var w = LayoutHarness.FindById(root, "w")!;
+
+ Assert.AreEqual("small-caps", w.FontVariant);
+ }
+
+ [TestMethod]
+ public void FontVariant_SmallCaps_ViaFontShorthand_ParsesAndStores()
+ {
+ var (root, _) = LayoutHarness.Layout(
+ LayoutHarness.Wrap("Hello "));
+ var w = LayoutHarness.FindById(root, "w")!;
+
+ Assert.AreEqual("small-caps", w.FontVariant);
+ }
+
+ [Ignore("HTML-Renderer's font-variant is storage-only - CssBox.FontVariant is set but never read anywhere " +
+ "in layout or paint (confirmed by grep and by direct execution: the word stays a single unsplit " +
+ "'Hello', not split into 'H' + 'ELLO' the way PeachPDF's synthesis pipeline produces). Real word " +
+ "splitting/scaling is out of scope for this fork; see class remarks.")]
+ [TestMethod]
+ public void SmallCaps_SplitsWordIntoCaseRuns()
+ {
+ var (root, _) = LayoutHarness.Layout(
+ LayoutHarness.Wrap("Hello "));
+ var box = FindWordsBox(root, "w");
+
+ // "Hello" -> "H" (already upper) + "ELLO" (synthesized small-caps run), per PeachPDF's real behavior.
+ Assert.AreEqual(2, box.Words.Count);
+ Assert.AreEqual("H", box.Words[0].Text);
+ Assert.AreEqual("ELLO", box.Words[1].Text);
+ }
+
+ [TestMethod]
+ public void NoSmallCaps_WordIsNotSplit_Regression()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap("Hello "));
+ var box = FindWordsBox(root, "w");
+
+ Assert.AreEqual(1, box.Words.Count);
+ Assert.AreEqual("Hello", box.Words[0].Text);
+ }
+
+ [TestMethod]
+ public void SmallCaps_WordWithNoLowercaseLetters_IsNotSplit()
+ {
+ var (root, _) = LayoutHarness.Layout(
+ LayoutHarness.Wrap("ABC "));
+ var box = FindWordsBox(root, "w");
+
+ Assert.AreEqual(1, box.Words.Count);
+ Assert.AreEqual("ABC", box.Words[0].Text);
+ }
+
+ // ─── font-variant-caps / all-small-caps: not a recognized property name anywhere in this fork (only the
+ // standalone "font-variant" property and its "normal|small-caps" values are wired up), so these always
+ // behave identically to plain unset font-variant - confirmed via grep, no case in CssUtils's property
+ // switch (get or set) mentions "font-variant-caps" at all. ────────────────────────────────────────────
+
+ [TestMethod]
+ public void AllSmallCaps_WordWithNoLowercaseLetters_WordStaysIntact()
+ {
+ // PeachPDF: font-variant-caps:all-small-caps shrinks an already-uppercase word (c2sc approximation).
+ // Here font-variant-caps isn't a recognized property at all, so this reduces to a plain unsplit-word
+ // regression check - it is not exercising any shrinking behavior.
+ var (root, _) = LayoutHarness.Layout(
+ LayoutHarness.Wrap("ABC "));
+ var box = FindWordsBox(root, "w");
+
+ Assert.AreEqual(1, box.Words.Count);
+ Assert.AreEqual("ABC", box.Words[0].Text);
+ }
+
+ [TestMethod]
+ public void AllSmallCaps_WordWithNoLetters_IsNotSplit()
+ {
+ var (root, _) = LayoutHarness.Layout(
+ LayoutHarness.Wrap("123 "));
+ var box = FindWordsBox(root, "w");
+
+ Assert.AreEqual(1, box.Words.Count);
+ Assert.AreEqual("123", box.Words[0].Text);
+ }
+
+ [Ignore("font-variant-caps isn't a recognized property in this fork (grep-confirmed absent from CssUtils's " +
+ "property switch), so there is no c2sc/small-caps approximation to split a mixed-case word into " +
+ "upper/lower runs - the word stays a single unsplit 'AbC', not the three runs " +
+ "('A','B','C') PeachPDF's synthesis produces.")]
+ [TestMethod]
+ public void AllSmallCaps_MixedCaseWord_WouldSplitIntoThreeRuns()
+ {
+ var (root, _) = LayoutHarness.Layout(
+ LayoutHarness.Wrap("AbC "));
+ var box = FindWordsBox(root, "w");
+
+ Assert.AreEqual(3, box.Words.Count);
+ Assert.AreEqual("A", box.Words[0].Text);
+ Assert.AreEqual("B", box.Words[1].Text);
+ Assert.AreEqual("C", box.Words[2].Text);
+ }
+
+ [Ignore("font-variant-caps isn't a recognized property in this fork, so there is no run-splitting at all - " +
+ "the word stays a single unsplit 'a1b', not the three runs ('A','1','B') PeachPDF's synthesis " +
+ "produces around the non-lowercase digit run.")]
+ [TestMethod]
+ public void AllSmallCaps_DigitRunBetweenLowercaseRuns_WouldSplitIntoThreeRuns()
+ {
+ var (root, _) = LayoutHarness.Layout(
+ LayoutHarness.Wrap("a1b "));
+ var box = FindWordsBox(root, "w");
+
+ Assert.AreEqual(3, box.Words.Count);
+ Assert.AreEqual("A", box.Words[0].Text);
+ Assert.AreEqual("1", box.Words[1].Text);
+ Assert.AreEqual("B", box.Words[2].Text);
+ }
+}
diff --git a/Source/Test/HtmlRenderer.IntegrationTest/Text/StyleElementTextConcatenationTests.cs b/Source/Test/HtmlRenderer.IntegrationTest/Text/StyleElementTextConcatenationTests.cs
new file mode 100644
index 000000000..dd247cd1d
--- /dev/null
+++ b/Source/Test/HtmlRenderer.IntegrationTest/Text/StyleElementTextConcatenationTests.cs
@@ -0,0 +1,81 @@
+using HtmlRenderer.IntegrationTest.TestSupport;
+
+namespace HtmlRenderer.IntegrationTest.Text;
+
+///
+/// Regression coverage for a <style> element whose CSS contains a < character (e.g. a
+/// content: "<" -style value). Ported from PeachPDF's StyleElementTextConcatenationTests , which
+/// exists because PeachPDF's HTML tokenizer splits such raw text into several data tokens at each < ,
+/// and PeachPDF's DomParser used to parse each fragment as an independent (possibly syntactically
+/// incomplete) stylesheet instead of concatenating them first - breaking any rule after the split point.
+///
+///
+///
+/// The same split premise is still real. This fork's DomParser.CascadeParseStyles
+/// (Core/Parse/DomParser.cs , ~line 134-135) still parses a <style> element's child text
+/// nodes independently in a foreach loop - _cssParser.ParseStyleSheet(cssData, child.Text) -
+/// with no concatenation, exactly like PeachPDF's bug. And this fork's HTML tokenizer (HtmlKit's
+/// HtmlTokenizer , used by HtmlParser.ParseDocument ) DOES split a <style> element's
+/// raw text into multiple data tokens at an embedded < , becoming two separate anonymous child
+/// <style> box.
+///
+///
+/// Verified against the CSS engine port: the previously-recorded "does not reproduce" conclusion is now
+/// stale and wrong. That conclusion relied on the OLD CssParser 's brace-matching scanner, which has
+/// been replaced entirely by the vendored ExCSS-derived tokenizer/grammar (same lineage as PeachPDF's own).
+/// Confirmed by direct execution against the built assembly: parsing the second text-node fragment
+/// ("<"; }\n #b { color: green; } ) alone now throws a real, unhandled
+/// System.NullReferenceException from StyleRule.SelectorText 's getter, via
+/// StylesheetComposer.CreateNestedStyleRule /TryCreateNestedRule (the new engine's CSS-Nesting
+/// support tries to parse the malformed leading fragment as an incomplete nested rule and dereferences a null
+/// selector while doing so). Because HtmlContainerInt.SetHtml is async Task and
+/// container.Root staying null after
+/// Clear() , which is what Assert.IsNotNull(container.Root)
+/// catches. So the underlying "no concatenation" premise is still real, and now manifests as a genuine crash
+/// bug in the new engine's CSS-Nesting parse path (not a silent "rule doesn't apply" the way PeachPDF's own
+/// bug read) - out of scope for this test-porting pass to fix in Core, so the regression test is left in and
+/// marked [Ignore] below with this freshly-verified reason, rather than silently deleted or left
+/// falsely documented as passing.
+///
+///
+// This fork's CssParser keeps a process-wide, non-thread-safe regex cache
+// (RegexParserUtils.GetRegex's static Dictionary) that SetHtml/DefaultCssData populate lazily on first use per
+// AppDomain; running HtmlContainerInt.SetHtml from more than one thread at once (as MSTestSettings.cs's
+// assembly-wide [Parallelize(Scope = ExecutionScope.MethodLevel)] does by default) can corrupt it and throw
+// "A concurrent update was performed on this collection". [DoNotParallelize] avoids tripping that pre-existing
+// library race rather than masking it.
+[DoNotParallelize]
+[TestClass]
+public sealed class StyleElementTextConcatenationTests
+{
+ [Ignore("CSS engine port regression, freshly verified: parsing the split text-node fragment " +
+ "'\"<\"; }\\n #b { color: green; }' now throws System.NullReferenceException from " +
+ "StyleRule.SelectorText via StylesheetComposer.CreateNestedStyleRule/TryCreateNestedRule (the " +
+ "new CSS-Nesting support dereferences a null selector on this malformed input). Because SetHtml " +
+ "is unawaited by LayoutHarness.Layout, the exception is silently swallowed and container.Root " +
+ "stays null - see this class's remarks for the full trace. Out of scope for this test-porting " +
+ "pass to fix in Core; left in and ignored so the regression stays visible rather than silently " +
+ "deleted.")]
+ [TestMethod]
+ public void RuleAfterLessThanInDeclaration_StillApplies()
+ {
+ const string html = """
+
+ a
b
+
+ """;
+
+ var (root, _) = LayoutHarness.Layout(html);
+ var b = LayoutHarness.FindById(root, "b")!;
+
+ Assert.IsNotNull(b);
+ // Without concatenation, "#b { color: green }" would need to land in a mis-parsed fragment starting
+ // at '<' and never apply, leaving the default "black" - see class remarks for what actually happens
+ // now (a crash, not a silent non-application).
+ Assert.AreEqual("green", b.Color);
+ }
+}
diff --git a/Source/Test/HtmlRenderer.IntegrationTest/Text/TextAlignStartEndIntegrationTests.cs b/Source/Test/HtmlRenderer.IntegrationTest/Text/TextAlignStartEndIntegrationTests.cs
new file mode 100644
index 000000000..0e0cc6ac6
--- /dev/null
+++ b/Source/Test/HtmlRenderer.IntegrationTest/Text/TextAlignStartEndIntegrationTests.cs
@@ -0,0 +1,112 @@
+using System.Linq;
+using HtmlRenderer.IntegrationTest.TestSupport;
+using TheArtOfDev.HtmlRenderer.Core.Dom;
+
+namespace HtmlRenderer.IntegrationTest.Text;
+
+///
+/// text-align 's CSS-correct initial value is start (CSS Text 3 §7.1), which is meant to resolve
+/// against the box's own direction at layout time - not always to left , the legacy/incorrect
+/// initial value this replaces. Ported from PeachPDF's TextAlignStartEndIntegrationTests .
+///
+///
+/// HTML-Renderer's CssBoxProperties.TextAlign is a plain, unvalidated string property - whatever
+/// literal value the stylesheet declares (including "start"/"end") is stored as-is, with no keyword
+/// whitelist. But CssLayoutEngine.ApplyHorizontalAlignment 's switch only has explicit cases for
+/// right /center /justify ; everything else - including start , end ,
+/// left , and unset - falls through to default -> ApplyLeftAlignment (itself a
+/// complete no-op: the words are simply left where FlowBox already placed them, which is against the
+/// line's own left edge, independent of the box's direction ). direction:rtl separately drives
+/// ApplyRightToLeft , but that only reorders multiple words' relative positions within a line - for a
+/// single-word line (as used below) it is a no-op.
+///
+/// Net effect, confirmed by direct execution against the built assembly: a text-align:start or
+/// text-align:end box always packs its text against the left edge, regardless of dir="rtl" .
+/// That happens to match two of the four PeachPDF start/end cases (the ones that expect left-edge packing)
+/// and diverge from the other two (which expect right-edge packing) - so only those two are ported as
+/// genuinely broken here.
+///
+///
+// This fork's CssParser keeps a process-wide, non-thread-safe regex cache
+// (RegexParserUtils.GetRegex's static Dictionary) that SetHtml/DefaultCssData populate lazily on first use per
+// AppDomain; running HtmlContainerInt.SetHtml from more than one thread at once (as MSTestSettings.cs's
+// assembly-wide [Parallelize(Scope = ExecutionScope.MethodLevel)] does by default) can corrupt it and throw
+// "A concurrent update was performed on this collection". [DoNotParallelize] avoids tripping that pre-existing
+// library race rather than masking it.
+[DoNotParallelize]
+[TestClass]
+public sealed class TextAlignStartEndIntegrationTests
+{
+ private const double Delta = 1.0;
+
+ private static CssRect FirstWord(CssBox box) =>
+ LayoutHarness.Descendants(box).SelectMany(b => b.Words).First(w => !w.IsSpaces);
+
+ [TestMethod]
+ public void Start_InLtrBlock_PacksTextAgainstTheLeftEdge()
+ {
+ var html = LayoutHarness.Wrap("hi
");
+
+ var (root, _) = LayoutHarness.Layout(html);
+ var p = LayoutHarness.FindById(root, "p")!;
+ var word = FirstWord(p);
+
+ Assert.AreEqual(p.ClientLeft, word.Left, Delta);
+ }
+
+ [Ignore("text-align:start falls through CssLayoutEngine.ApplyHorizontalAlignment's switch to the default " +
+ "(left-align) case regardless of direction - confirmed by direct execution: a dir='rtl' box with " +
+ "text-align:start still packs its word against the left edge (word.Left == ClientLeft), not the " +
+ "right edge this test (correctly, per CSS Text 3) expects.")]
+ [TestMethod]
+ public void Start_InRtlBlock_PacksTextAgainstTheRightEdge()
+ {
+ var html = LayoutHarness.Wrap("hi
");
+
+ var (root, _) = LayoutHarness.Layout(html);
+ var p = LayoutHarness.FindById(root, "p")!;
+ var word = FirstWord(p);
+
+ Assert.AreEqual(p.ClientRight, word.Right, Delta);
+ }
+
+ [Ignore("text-align:end falls through CssLayoutEngine.ApplyHorizontalAlignment's switch to the default " +
+ "(left-align) case - confirmed by direct execution: an LTR box with text-align:end still packs " +
+ "its word against the left edge (word.Left == ClientLeft), not the right edge this test " +
+ "(correctly, per CSS Text 3) expects.")]
+ [TestMethod]
+ public void End_InLtrBlock_PacksTextAgainstTheRightEdge()
+ {
+ var html = LayoutHarness.Wrap("hi
");
+
+ var (root, _) = LayoutHarness.Layout(html);
+ var p = LayoutHarness.FindById(root, "p")!;
+ var word = FirstWord(p);
+
+ Assert.AreEqual(p.ClientRight, word.Right, Delta);
+ }
+
+ [TestMethod]
+ public void End_InRtlBlock_PacksTextAgainstTheLeftEdge()
+ {
+ var html = LayoutHarness.Wrap("hi
");
+
+ var (root, _) = LayoutHarness.Layout(html);
+ var p = LayoutHarness.FindById(root, "p")!;
+ var word = FirstWord(p);
+
+ Assert.AreEqual(p.ClientLeft, word.Left, Delta);
+ }
+
+ [TestMethod]
+ public void DefaultsToStart_UnsetTextAlign_BehavesLikeLeftInLtr()
+ {
+ var html = LayoutHarness.Wrap("hi
");
+
+ var (root, _) = LayoutHarness.Layout(html);
+ var p = LayoutHarness.FindById(root, "p")!;
+ var word = FirstWord(p);
+
+ Assert.AreEqual(p.ClientLeft, word.Left, Delta);
+ }
+}
diff --git a/Source/Test/HtmlRenderer.IntegrationTest/Text/VerticalAlignIntegrationTests.cs b/Source/Test/HtmlRenderer.IntegrationTest/Text/VerticalAlignIntegrationTests.cs
new file mode 100644
index 000000000..471e15996
--- /dev/null
+++ b/Source/Test/HtmlRenderer.IntegrationTest/Text/VerticalAlignIntegrationTests.cs
@@ -0,0 +1,288 @@
+using System.Linq;
+using HtmlRenderer.IntegrationTest.TestSupport;
+
+namespace HtmlRenderer.IntegrationTest.Text;
+
+///
+/// Verifies whether vertical-align actually repositions inline-level content relative to its line box.
+/// Ported from PeachPDF's VerticalAlignIntegrationTests , whose header describes a fixed bug: in
+/// PeachPDF, top /bottom /middle /text-top /text-bottom used to hit an empty
+/// case in CssLayoutEngine.ApplyVerticalAlignment and were silent no-ops, while baseline /
+/// sub /super (and, in PeachPDF, table cells via the separate ApplyCellVerticalAlignment )
+/// genuinely worked.
+///
+///
+///
+/// HTML-Renderer's ApplyVerticalAlignment (Core/Dom/CssLayoutEngine.cs ) has the same empty
+/// case bodies for top /bottom /middle /text-top /text-bottom that
+/// PeachPDF used to have, and real logic for sub /super /baseline (via
+/// CssLineBox.SetBaseLine ). But confirmed by direct execution against the built assembly, that
+/// sub /super logic never actually moves ordinary inline content either - for the completely
+/// standard <span style="vertical-align:sub">text</span> shape this file's helper uses
+/// (and PeachPDF's did too), two things combine to make it a no-op:
+///
+///
+/// - Text is always split into its own anonymous child
CssBox
+/// (DomParser.CorrectTextBoxes ) - the <span> itself owns no CssBox.Words
+/// directly, its anonymous text child does.
+/// vertical-align is not copied by the normal (non-"everything") overload of
+/// CssBoxProperties.InheritStyle (Core/Dom/CssBoxProperties.cs , ~line 1490-1565) - so that
+/// anonymous text child never inherits the span's vertical-align and keeps the default "baseline"
+/// case.
+///
+/// CssLineBox.SetBaseLine(g, box, baseline) only ever moves the words returned by
+/// WordsOf(box) (an exact word.OwnerBox == box match). So the switch's sub /super
+/// branches do run for the <span> itself (which has the real vertical-align value) but
+/// touch zero words (WordsOf(span) is empty), while the branch that runs for the anonymous text child
+/// (which owns the real word) always takes the default /baseline case, because that child's own
+/// vertical-align was never inherited. Net result, confirmed empirically: laying out eleven variants
+/// (top , bottom , middle , text-top , text-bottom , sub , super ,
+/// baseline , and numeric/percentage lengths, none of which have any case in the switch at all)
+/// produced the exact same word Top in every case - inline vertical-align is a total no-op in
+/// this fork for the ordinary "element wraps a text node" markup shape.
+///
+///
+/// Table cells are unaffected by any of this: ApplyCellVerticalAlignment is a separate code path that
+/// calls b.OffsetTop(dist) directly on every child box of the cell (bypassing WordsOf and
+/// inheritance entirely), and top /middle /bottom there are confirmed genuinely working by
+/// direct execution (distinct word tops for top/middle/bottom, with middle landing exactly at the midpoint) -
+/// so the two table-cell cases below are ported as real, non-ignored tests.
+///
+///
+// This fork's CssParser keeps a process-wide, non-thread-safe regex cache
+// (RegexParserUtils.GetRegex's static Dictionary) that SetHtml/DefaultCssData populate lazily on first use per
+// AppDomain; running HtmlContainerInt.SetHtml from more than one thread at once (as MSTestSettings.cs's
+// assembly-wide [Parallelize(Scope = ExecutionScope.MethodLevel)] does by default) can corrupt it and throw
+// "A concurrent update was performed on this collection". [DoNotParallelize] avoids tripping that pre-existing
+// library race rather than masking it.
+[DoNotParallelize]
+[TestClass]
+public sealed class VerticalAlignIntegrationTests
+{
+ private const double Delta = 0.5;
+
+ private const string InlineNoOpReason =
+ "HTML-Renderer's inline vertical-align is a total no-op for the standard text shape " +
+ "used here - confirmed by direct execution: the span's own Words collection is always empty (text " +
+ "lives on an anonymous child box instead), and that anonymous child never inherits vertical-align " +
+ "(CssBoxProperties.InheritStyle's normal overload does not copy it), so it always takes the " +
+ "default/baseline case in CssLayoutEngine.ApplyVerticalAlignment regardless of what the span's own " +
+ "vertical-align was set to. See class remarks for the full mechanism.";
+
+ private static double GetAlignedTop(string verticalAlign, string? lineHeight = null)
+ {
+ // "v" is deliberately smaller than its parent's own font (10px vs 16px) - text-top/text-bottom align
+ // with the *parent's* font box, and if the aligned box were taller than that reference box, "top"
+ // and "bottom" alignment could legitimately cross over.
+ var lineHeightDecl = lineHeight is null ? "" : $"; line-height:{lineHeight}";
+ var html = LayoutHarness.Wrap(
+ "TALL " +
+ $"small
");
+
+ var (root, _) = LayoutHarness.Layout(html);
+ var v = LayoutHarness.FindById(root, "v")!;
+ return LayoutHarness.Descendants(v).SelectMany(b => b.Words).First().Top;
+ }
+
+ [Ignore(InlineNoOpReason)]
+ [TestMethod]
+ public void Top_PositionsHigherThanBottom()
+ {
+ var topY = GetAlignedTop("top");
+ var bottomY = GetAlignedTop("bottom");
+
+ Assert.IsTrue(topY < bottomY, $"expected top-aligned span ({topY}) to sit above bottom-aligned span ({bottomY})");
+ }
+
+ [Ignore(InlineNoOpReason)]
+ [TestMethod]
+ public void Middle_PositionsBetweenTopAndBottom()
+ {
+ var topY = GetAlignedTop("top");
+ var bottomY = GetAlignedTop("bottom");
+ var middleY = GetAlignedTop("middle");
+
+ Assert.IsTrue(middleY > topY && middleY < bottomY);
+ }
+
+ [Ignore(InlineNoOpReason)]
+ [TestMethod]
+ public void TextTop_PositionsAboveTextBottom()
+ {
+ var textTopY = GetAlignedTop("text-top");
+ var textBottomY = GetAlignedTop("text-bottom");
+
+ Assert.IsTrue(textTopY < textBottomY, $"top={textTopY} bottom={textBottomY}");
+ }
+
+ [Ignore(InlineNoOpReason)]
+ [TestMethod]
+ public void Sub_PositionsBelowSuper()
+ {
+ var subY = GetAlignedTop("sub");
+ var superY = GetAlignedTop("super");
+
+ Assert.IsTrue(subY > superY, $"sub={subY} super={superY}");
+ }
+
+ [Ignore(InlineNoOpReason)]
+ [TestMethod]
+ public void Bottom_DiffersFromDefaultBaselineAlignment()
+ {
+ var bottomY = GetAlignedTop("bottom");
+ var baselineY = GetAlignedTop("baseline");
+
+ Assert.AreNotEqual(baselineY, bottomY);
+ }
+
+ [Ignore(InlineNoOpReason)]
+ [TestMethod]
+ public void Middle_DiffersFromDefaultBaselineAlignment()
+ {
+ var middleY = GetAlignedTop("middle");
+ var baselineY = GetAlignedTop("baseline");
+
+ Assert.AreNotEqual(baselineY, middleY);
+ }
+
+ [TestMethod]
+ public void TextTop_ReferencesParentFontAscent_NotJustLineTop()
+ {
+ // text-top aligns with the top of the *parent's* font (CSS1 §5.6.11), not the line's raw top extent
+ // the way plain "top" does - changing only the parent's font-size (the target span stays fixed at
+ // 10px in both builds) must still move the result, proving the parent's font metrics are actually
+ // consulted rather than this collapsing to plain "top".
+ var htmlSmallParent = LayoutHarness.Wrap(
+ "TALL " +
+ "small
");
+ var htmlLargeParent = LayoutHarness.Wrap(
+ "TALL " +
+ "small
");
+
+ var (rootSmall, _) = LayoutHarness.Layout(htmlSmallParent);
+ var (rootLarge, _) = LayoutHarness.Layout(htmlLargeParent);
+
+ var vSmall = LayoutHarness.FindById(rootSmall, "v")!;
+ var vLarge = LayoutHarness.FindById(rootLarge, "v")!;
+ var ySmall = LayoutHarness.Descendants(vSmall).SelectMany(b => b.Words).First().Top;
+ var yLarge = LayoutHarness.Descendants(vLarge).SelectMany(b => b.Words).First().Top;
+
+ Assert.AreNotEqual(ySmall, yLarge);
+ }
+
+ [TestMethod]
+ public void Bottom_OnATableCell_PushesShortContentLowerThanTopAligned()
+ {
+ // CssLayoutEngine.ApplyCellVerticalAlignment's table-specific alignment algorithm (distinct from the
+ // inline ApplyVerticalAlignment exercised by the other tests in this file) - a short cell in a taller
+ // row must be pushed all the way to the row's bottom under vertical-align:bottom, unlike
+ // vertical-align:top where it stays put.
+ var htmlTop = LayoutHarness.Wrap(
+ ""
+ + "Tall "
+ + "Short "
+ + "
");
+ var htmlBottom = LayoutHarness.Wrap(
+ ""
+ + "Tall "
+ + "Short "
+ + "
");
+
+ var (rootTop, _) = LayoutHarness.Layout(htmlTop);
+ var (rootBottom, _) = LayoutHarness.Layout(htmlBottom);
+
+ var topY = LayoutHarness.Descendants(LayoutHarness.FindById(rootTop, "v")!).SelectMany(b => b.Words).First().Top;
+ var bottomY = LayoutHarness.Descendants(LayoutHarness.FindById(rootBottom, "v")!).SelectMany(b => b.Words).First().Top;
+
+ Assert.IsTrue(bottomY > topY,
+ $"vertical-align:bottom ({bottomY}) should push the cell's content lower than vertical-align:top ({topY})");
+ }
+
+ [TestMethod]
+ public void Middle_OnATableCellWithExplicitHeight_CentersShortContent()
+ {
+ var htmlTop = LayoutHarness.Wrap(
+ ""
+ + "Tall "
+ + "Short "
+ + "
");
+ var htmlMiddle = LayoutHarness.Wrap(
+ ""
+ + "Tall "
+ + "Short "
+ + "
");
+ var htmlBottom = LayoutHarness.Wrap(
+ ""
+ + "Tall "
+ + "Short "
+ + "
");
+
+ var (rootTop, _) = LayoutHarness.Layout(htmlTop);
+ var (rootMiddle, _) = LayoutHarness.Layout(htmlMiddle);
+ var (rootBottom, _) = LayoutHarness.Layout(htmlBottom);
+
+ var topY = LayoutHarness.Descendants(LayoutHarness.FindById(rootTop, "v")!).SelectMany(b => b.Words).First().Top;
+ var middleY = LayoutHarness.Descendants(LayoutHarness.FindById(rootMiddle, "v")!).SelectMany(b => b.Words).First().Top;
+ var bottomY = LayoutHarness.Descendants(LayoutHarness.FindById(rootBottom, "v")!).SelectMany(b => b.Words).First().Top;
+
+ Assert.IsTrue(middleY > topY && middleY < bottomY,
+ $"vertical-align:middle ({middleY}) should land strictly between vertical-align:top ({topY}) and vertical-align:bottom ({bottomY}) even with an explicit cell height");
+
+ // ApplyCellVerticalAlignment splits the leftover room evenly for `middle` (half of what `bottom`
+ // moves it by), so middle must sit at the exact midpoint.
+ Assert.AreEqual((topY + bottomY) / 2, middleY, Delta);
+ }
+
+ [Ignore(InlineNoOpReason + " Numeric/percentage lengths have no case at all in the switch, so they fall " +
+ "to the same no-op default path.")]
+ [TestMethod]
+ public void Length_PositiveValue_RaisesTheBoxAboveBaseline()
+ {
+ // CSS 2.1 §10.8.1: a positive length raises the box by that distance from its own baseline.
+ var baselineY = GetAlignedTop("baseline");
+ var raisedY = GetAlignedTop("5px");
+
+ Assert.IsTrue(raisedY < baselineY, $"raised={raisedY} baseline={baselineY}");
+ }
+
+ [Ignore(InlineNoOpReason + " Numeric/percentage lengths have no case at all in the switch, so they fall " +
+ "to the same no-op default path.")]
+ [TestMethod]
+ public void Length_NegativeValue_LowersTheBoxBelowBaseline()
+ {
+ var baselineY = GetAlignedTop("baseline");
+ var loweredY = GetAlignedTop("-5px");
+
+ Assert.IsTrue(loweredY > baselineY, $"lowered={loweredY} baseline={baselineY}");
+ }
+
+ [Ignore(InlineNoOpReason + " Numeric/percentage lengths have no case at all in the switch, so they fall " +
+ "to the same no-op default path.")]
+ [TestMethod]
+ public void Percentage_PositiveValue_RaisesTheBoxAboveBaseline()
+ {
+ var baselineY = GetAlignedTop("baseline");
+ var raisedY = GetAlignedTop("50%");
+
+ Assert.IsTrue(raisedY < baselineY, $"raised={raisedY} baseline={baselineY}");
+ }
+
+ [TestMethod]
+ public void Percentage_ResolvesAgainstTheBoxsOwnLineHeight()
+ {
+ // A percentage is a fraction of the box's own line-height (CSS 2.1 §10.8.1) - doubling the
+ // line-height (everything else unchanged) must double the raise relative to that line-height's own
+ // baseline, proving the percentage is actually resolved against it rather than some other fixed
+ // reference (e.g. font-size).
+ var baseline20 = GetAlignedTop("baseline", lineHeight: "20px");
+ var percent20 = GetAlignedTop("50%", lineHeight: "20px");
+ var baseline40 = GetAlignedTop("baseline", lineHeight: "40px");
+ var percent40 = GetAlignedTop("50%", lineHeight: "40px");
+
+ var raise20 = baseline20 - percent20;
+ var raise40 = baseline40 - percent40;
+
+ Assert.AreEqual(raise20 * 2, raise40, Delta);
+ }
+}
diff --git a/Source/Test/HtmlRenderer.IntegrationTest/Text/WhiteSpaceLayoutIntegrationTests.cs b/Source/Test/HtmlRenderer.IntegrationTest/Text/WhiteSpaceLayoutIntegrationTests.cs
new file mode 100644
index 000000000..8a2829e4d
--- /dev/null
+++ b/Source/Test/HtmlRenderer.IntegrationTest/Text/WhiteSpaceLayoutIntegrationTests.cs
@@ -0,0 +1,148 @@
+using System.Linq;
+using HtmlRenderer.IntegrationTest.TestSupport;
+
+namespace HtmlRenderer.IntegrationTest.Text;
+
+///
+/// Verifies white-space actually affects whitespace-collapsing and line-wrapping -
+/// CssBox.ParseToWords /CssLayoutEngine.FlowBox fully implement it.
+///
+[DoNotParallelize]
+[TestClass]
+public sealed class WhiteSpaceLayoutIntegrationTests
+{
+ [TestMethod]
+ public void Pre_PreservesMultipleConsecutiveSpacesAsLiteralWord()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap("A B
"));
+ var p = LayoutHarness.FindById(root, "p")!;
+ var words = p.LineBoxes[0].Words;
+
+ Assert.IsTrue(words.Any(w => w.Text == " "));
+ }
+
+ [TestMethod]
+ public void Normal_CollapsesConsecutiveSpaces_NoLiteralSpaceWord()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap("A B
"));
+ var p = LayoutHarness.FindById(root, "p")!;
+ var words = p.LineBoxes[0].Words;
+
+ Assert.IsFalse(words.Any(w => w.Text != null && w.Text.Length > 0 && w.Text.All(char.IsWhiteSpace)));
+ }
+
+ [TestMethod]
+ public void Pre_TreatsExplicitNewlineAsForcedLineBreak()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap("A\nB
"));
+ var p = LayoutHarness.FindById(root, "p")!;
+
+ Assert.AreEqual(2, p.LineBoxes.Count);
+ }
+
+ [TestMethod]
+ public void Normal_IgnoresEmbeddedNewline_NoForcedBreak()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap("A\nB
"));
+ var p = LayoutHarness.FindById(root, "p")!;
+
+ Assert.AreEqual(1, p.LineBoxes.Count);
+ }
+
+ [TestMethod]
+ public void NoWrap_PreventsWrapping_EvenWhenNarrowerThanContent()
+ {
+ var html = LayoutHarness.Wrap("a long run of unwrapped text here
");
+ var (root, _) = LayoutHarness.Layout(html);
+ var p = LayoutHarness.FindById(root, "p")!;
+
+ Assert.AreEqual(1, p.LineBoxes.Count);
+ }
+
+ [TestMethod]
+ public void Normal_WrapsAtNarrowWidth_ForContrastWithNoWrap()
+ {
+ var html = LayoutHarness.Wrap("a long run of unwrapped text here
");
+ var (root, _) = LayoutHarness.Layout(html);
+ var p = LayoutHarness.FindById(root, "p")!;
+
+ Assert.IsTrue(p.LineBoxes.Count > 1);
+ }
+
+ // ─── (U+00A0) is significant, non-collapsible, non-breaking content - unlike ordinary
+ // whitespace, which stays collapsible/breakable (CSS2.1 §16.4.1) ───────────
+
+ [Ignore("HtmlUtils.DecodeHtml decodes to a plain U+0020 space rather than U+00A0 (non-breaking " +
+ "space), so it is collapsed away like ordinary whitespace-only content instead of surviving as " +
+ "significant content with real height. Confirmed real engine behavior, not a porting mistake - " +
+ "same root cause tracked for HtmlEntityDecodingIntegrationTests.")]
+ [TestMethod]
+ public void Nbsp_OnlyContent_ProducesNonZeroHeight_MatchingRealText()
+ {
+ var (nbspRoot, _) = LayoutHarness.Layout(LayoutHarness.Wrap("
"));
+ var (textRoot, _) = LayoutHarness.Layout(LayoutHarness.Wrap("A
"));
+ var nbspBox = LayoutHarness.FindById(nbspRoot, "b")!;
+ var textBox = LayoutHarness.FindById(textRoot, "b")!;
+
+ var nbspHeight = nbspBox.ActualBottom - nbspBox.Location.Y;
+ var textHeight = textBox.ActualBottom - textBox.Location.Y;
+
+ Assert.IsTrue(nbspHeight > 0, $"Expected non-zero height for nbsp-only content, got {nbspHeight}");
+ Assert.IsTrue(nbspHeight >= textHeight - 1 && nbspHeight <= textHeight + 1);
+ }
+
+ [TestMethod]
+ public void OrdinaryWhitespaceOnlyContent_StillProducesZeroHeight_NoRegression()
+ {
+ var (root, _) = LayoutHarness.Layout(LayoutHarness.Wrap("
"));
+ var box = LayoutHarness.FindById(root, "b")!;
+
+ var height = box.ActualBottom - box.Location.Y;
+ Assert.IsTrue(height >= 0 && height <= 0.5);
+ }
+
+ [Ignore("HtmlUtils.DecodeHtml decodes to a plain U+0020 space rather than U+00A0, so it is treated " +
+ "as an ordinary breakable/collapsible space instead of a non-breaking one - the narrow-width case " +
+ "wraps just like the plain-space case instead of staying on one line. Confirmed real engine " +
+ "behavior, not a porting mistake - same root cause tracked for HtmlEntityDecodingIntegrationTests.")]
+ [TestMethod]
+ public void Nbsp_BetweenTokens_PreventsLineWrap_ContrastOrdinarySpace()
+ {
+ // Narrow enough that an ordinary space between "10" and "km" wraps to two lines, but a
+ // non-breaking space between them must never be treated as a break opportunity.
+ var (nbspRoot, _) = LayoutHarness.Layout(LayoutHarness.Wrap("10 km
"));
+ var pNbsp = LayoutHarness.FindById(nbspRoot, "p")!;
+
+ var (spaceRoot, _) = LayoutHarness.Layout(LayoutHarness.Wrap("10 km
"));
+ var pSpace = LayoutHarness.FindById(spaceRoot, "p")!;
+
+ Assert.AreEqual(1, pNbsp.LineBoxes.Count);
+ Assert.IsTrue(pSpace.LineBoxes.Count > 1,
+ "expected ordinary space to still allow wrapping, for contrast with nbsp");
+ }
+
+ // ─── word-break: break-all forces a mid-word break normal cannot find ──────
+
+ [TestMethod]
+ public void BreakAll_ForcesMidWordBreak_ContrastNormal()
+ {
+ // A single unbroken run with no space anywhere: "normal" has no break opportunity at all
+ // and must lay the whole word out on one (overflowing) line, while "break-all" must wrap it.
+ const string longWord = "abcdefghijklmnopqrstuvwxyz";
+
+ var (normalRoot, _) = LayoutHarness.Layout(LayoutHarness.Wrap($"{longWord}
"));
+ var pNormal = LayoutHarness.FindById(normalRoot, "p")!;
+
+ var (breakAllRoot, _) = LayoutHarness.Layout(
+ LayoutHarness.Wrap($"{longWord}
"));
+ var pBreakAll = LayoutHarness.FindById(breakAllRoot, "p")!;
+
+ // An overflowing word can push a leading empty line box ahead of it regardless of
+ // word-break - count only the lines that actually carry part of the word.
+ Assert.AreEqual(1, LinesWithWordContent(pNormal));
+ Assert.IsTrue(LinesWithWordContent(pBreakAll) > 1, "expected break-all to force a mid-word break");
+ }
+
+ private static int LinesWithWordContent(TheArtOfDev.HtmlRenderer.Core.Dom.CssBox box) =>
+ box.LineBoxes.Count(lb => lb.Words.Any(w => !string.IsNullOrEmpty(w.Text)));
+}
diff --git a/Source/Test/HtmlRenderer.PdfSharp.Test/PageSizeConverterTests.cs b/Source/Test/HtmlRenderer.PdfSharp.Test/PageSizeConverterTests.cs
new file mode 100644
index 000000000..59fea4cca
--- /dev/null
+++ b/Source/Test/HtmlRenderer.PdfSharp.Test/PageSizeConverterTests.cs
@@ -0,0 +1,32 @@
+using PdfSharp;
+
+namespace HtmlRenderer.PdfSharp.Test;
+
+///
+/// Tests for
+[TestClass]
+public sealed class PageSizeConverterTests
+{
+ [TestMethod]
+ [DataRow(PageSize.A4, 595d, 842d)]
+ [DataRow(PageSize.Letter, 612d, 792d)]
+ [DataRow(PageSize.Legal, 612d, 1008d)]
+ [DataRow(PageSize.A0, 2384d, 3370d)]
+ [DataRow(PageSize.Tabloid, 792d, 1224d)]
+ public void ToSize_KnownPageSize_ReturnsExpectedPointDimensions(PageSize pageSize, double expectedWidth, double expectedHeight)
+ {
+ var size = PageSizeConverter.ToSize(pageSize);
+
+ Assert.AreEqual(expectedWidth, size.Width);
+ Assert.AreEqual(expectedHeight, size.Height);
+ }
+
+ [TestMethod]
+ public void ToSize_Undefined_Throws()
+ {
+ Assert.ThrowsExactly(() => PageSizeConverter.ToSize(PageSize.Undefined));
+ }
+}
diff --git a/Source/Test/HtmlRenderer.PdfSharp.Test/PdfGeneratorTests.cs b/Source/Test/HtmlRenderer.PdfSharp.Test/PdfGeneratorTests.cs
index f98e20235..f433cbcd9 100644
--- a/Source/Test/HtmlRenderer.PdfSharp.Test/PdfGeneratorTests.cs
+++ b/Source/Test/HtmlRenderer.PdfSharp.Test/PdfGeneratorTests.cs
@@ -112,6 +112,32 @@ public async Task GeneratePdf_FromHtml_WithMultipleFonts_CreatesPdfDocument()
File.WriteAllBytes(pdfPath, pdf);
}
+ [TestMethod]
+ public async Task GeneratePdf_SimpleHtml_ProducesAtLeastOnePage()
+ {
+ // Act
+ using var document = await PdfGenerator.GeneratePdf("Hello
", PageSize.A4);
+
+ // Assert
+ Assert.IsTrue(document.Pages.Count >= 1);
+ }
+
+ [TestMethod]
+ public async Task GeneratePdf_SimpleHtml_CanBeSaved()
+ {
+ // Arrange
+ using var document = await PdfGenerator.GeneratePdf("Hello
", PageSize.A4);
+
+ // Act
+ using var stream = new MemoryStream();
+ document.Save(stream, false);
+
+ // Assert
+ var pdf = stream.ToArray();
+ Assert.IsGreaterThan(4, pdf.Length);
+ Assert.AreEqual("%PDF", System.Text.Encoding.ASCII.GetString(pdf, 0, 4));
+ }
+
private static void OnImageLoadPdfSharp(object? sender, HtmlImageLoadEventArgs e)
{
if (!string.Equals(e.Src, "ImageIcon", StringComparison.OrdinalIgnoreCase))
diff --git a/Source/Test/HtmlRenderer.PdfSharp.Test/PdfSharpAdapterColorTests.cs b/Source/Test/HtmlRenderer.PdfSharp.Test/PdfSharpAdapterColorTests.cs
new file mode 100644
index 000000000..aa25e3c9a
--- /dev/null
+++ b/Source/Test/HtmlRenderer.PdfSharp.Test/PdfSharpAdapterColorTests.cs
@@ -0,0 +1,40 @@
+using TheArtOfDev.HtmlRenderer.PdfSharp.Adapters;
+
+namespace HtmlRenderer.PdfSharp.Test;
+
+///
+/// Direct unit tests for GetColorInt ), which maps a CSS/system color name to an RColor by
+/// matching it against PdfSharp's known-color table (XColorResourceManager ).
+/// Guards that name lookup path against regression.
+///
+[TestClass]
+public sealed class PdfSharpAdapterColorTests
+{
+ [TestMethod]
+ [DataRow("Red", (byte)255, (byte)0, (byte)0)]
+ [DataRow("red", (byte)255, (byte)0, (byte)0)] // case-insensitive
+ [DataRow("Lime", (byte)0, (byte)255, (byte)0)]
+ [DataRow("Blue", (byte)0, (byte)0, (byte)255)]
+ public void GetColor_KnownColorName_ResolvesToRgb(string name, byte r, byte g, byte b)
+ {
+ var adapter = PdfSharpAdapter.Instance;
+
+ var color = adapter.GetColor(name);
+
+ Assert.IsFalse(color.IsEmpty);
+ Assert.AreEqual(r, color.R);
+ Assert.AreEqual(g, color.G);
+ Assert.AreEqual(b, color.B);
+ }
+
+ [TestMethod]
+ public void GetColor_UnknownColorName_ReturnsEmpty()
+ {
+ var adapter = PdfSharpAdapter.Instance;
+
+ var color = adapter.GetColor("not-a-real-color-name");
+
+ Assert.IsTrue(color.IsEmpty);
+ }
+}
diff --git a/Source/Test/HtmlRenderer.Test/Css/AnimationPropertyTests.cs b/Source/Test/HtmlRenderer.Test/Css/AnimationPropertyTests.cs
new file mode 100644
index 000000000..c9682c503
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Css/AnimationPropertyTests.cs
@@ -0,0 +1,607 @@
+using HtmlRenderer.Test.CssEngineSupport;
+using TheArtOfDev.HtmlRenderer.Core.CssEngine;
+
+namespace HtmlRenderer.Test.Css;
+
+/// Ported from PeachPDF.Tests/CSS/PropertyTests/AnimationPropertyTests.cs. Pure CSSOM parse tests - no layout involved.
+[TestClass]
+public sealed class AnimationPropertyTests
+{
+ [TestMethod]
+ public void AnimationDurationMillisecondsLegal()
+ {
+ var snippet = "animation-duration : 60ms";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-duration", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationDurationProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("60ms", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationDurationMultipleSecondsLegal()
+ {
+ var snippet = "animation-duration : 1s , 2s , 3s , 4s";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-duration", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationDurationProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("1s, 2s, 3s, 4s", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationDelayMillisecondsLegal()
+ {
+ var snippet = "animation-delay : 0ms";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-delay", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationDelayProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("0ms", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationDelayZeroIllegal()
+ {
+ var snippet = "animation-delay : 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-delay", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationDelayProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void AnimationDelayZeroZeroSecondMillisecondsLegal()
+ {
+ var snippet = "animation-delay : 0s , 0s , 1s , 20ms";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-delay", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationDelayProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("0s, 0s, 1s, 20ms", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationNameDashSpecificLegal()
+ {
+ var snippet = "animation-name : -specific";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-name", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationNameProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("-specific", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationNameSlidingVerticallyLegal()
+ {
+ var snippet = "animation-name : sliding-vertically";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-name", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationNameProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("sliding-vertically", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationNameTest05Legal()
+ {
+ var snippet = "animation-name : test_05";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-name", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationNameProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("test_05", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationNameNumberIllegal()
+ {
+ var snippet = "animation-name : 42";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-name", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationNameProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void AnimationNameShouldKeepLetterCasing()
+ {
+ var snippet = "animation-name : MyAnimation";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-name", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationNameProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("MyAnimation", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationNameMyAnimationOtherAnimationLegal()
+ {
+ var snippet = "animation-name : my-animation, other-animation";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-name", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationNameProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("my-animation, other-animation", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationIterationCountZeroLegal()
+ {
+ var snippet = "animation-iteration-count : 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-iteration-count", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationIterationCountProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("0", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationIterationCountInfiniteLegal()
+ {
+ var snippet = "animation-iteration-count : infinite";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-iteration-count", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationIterationCountProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("infinite", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationIterationCountInfiniteUppercaseLegal()
+ {
+ var snippet = "animation-iteration-count : INFINITE";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-iteration-count", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationIterationCountProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("infinite", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationIterationCountFloatLegal()
+ {
+ var snippet = "animation-iteration-count : 2.3";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-iteration-count", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationIterationCountProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("2.3", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationIterationCountTwoZeroInfiniteLegal()
+ {
+ var snippet = "animation-iteration-count : 2, 0, infinite";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-iteration-count", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationIterationCountProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("2, 0, infinite", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationIterationCountNegativeIllegal()
+ {
+ var snippet = "animation-iteration-count : -1";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-iteration-count", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationIterationCountProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void AnimationTimingFunctionEaseUppercaseLegal()
+ {
+ var snippet = "animation-timing-function : EASE";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-timing-function", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationTimingFunctionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("ease", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationTimingFunctionNoneIllegal()
+ {
+ var snippet = "animation-timing-function : none";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-timing-function", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationTimingFunctionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void AnimationTimingFunctionEaseInOutLegal()
+ {
+ var snippet = "animation-timing-function : ease-IN-out";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-timing-function", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationTimingFunctionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("ease-in-out", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationTimingFunctionStepEndLegal()
+ {
+ var snippet = "animation-timing-function : step-END";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-timing-function", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationTimingFunctionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("step-end", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationTimingFunctionStepStartLinearLegal()
+ {
+ var snippet = "animation-timing-function : step-start , LINeAr";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-timing-function", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationTimingFunctionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("step-start, linear", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationTimingFunctionStepStartCubicBezierLegal()
+ {
+ var snippet = "animation-timing-function : step-start , cubic-bezier(0,1,1,1)";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-timing-function", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationTimingFunctionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("step-start, cubic-bezier(0, 1, 1, 1)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationPlayStateRunningLegal()
+ {
+ var snippet = "animation-play-state: running";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-play-state", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationPlayStateProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("running", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationPlayStatePausedUppercaseLegal()
+ {
+ var snippet = "animation-play-state: PAUSED";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-play-state", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationPlayStateProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("paused", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationPlayStatePausedRunningPausedLegal()
+ {
+ var snippet = "animation-play-state: paused, Running, paused";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-play-state", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationPlayStateProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("paused, running, paused", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationFillModeNoneLegal()
+ {
+ var snippet = "animation-fill-mode: none";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-fill-mode", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationFillModeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("none", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationFillModeZeroIllegal()
+ {
+ var snippet = "animation-fill-mode: 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-fill-mode", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationFillModeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void AnimationFillModeBackwardsLegal()
+ {
+ var snippet = "animation-fill-mode: backwards !important";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-fill-mode", property.Name);
+ Assert.IsTrue(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationFillModeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("backwards", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationFillModeForwardsUppercaseLegal()
+ {
+ var snippet = "animation-fill-mode: FORWARDS";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-fill-mode", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationFillModeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("forwards", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationFillModeBothBackwardsForwardsNoneLegal()
+ {
+ var snippet = "animation-fill-mode: both , backwards , forwards ,NONE";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-fill-mode", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationFillModeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("both, backwards, forwards, none", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationDirectionNormalLegal()
+ {
+ var snippet = "animation-direction: normal";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-direction", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationDirectionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("normal", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationDirectionReverseLegal()
+ {
+ var snippet = "animation-direction : reverse";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-direction", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationDirectionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("reverse", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationDirectionNoneIllegal()
+ {
+ var snippet = "animation-direction : none";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-direction", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationDirectionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void AnimationDirectionAlternateReverseUppercaseLegal()
+ {
+ var snippet = "animation-direction : alternate-REVERSE";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-direction", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationDirectionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("alternate-reverse", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationDirectionNormalAlternateReverseAlternateReverseLegal()
+ {
+ var snippet = "animation-direction: normal,alternate , reverse ,ALTERNATE-reverse !important";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation-direction", property.Name);
+ Assert.IsTrue(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationDirectionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("normal, alternate, reverse, alternate-reverse", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationIterationCountLegal()
+ {
+ var snippet = "animation : 5";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("5", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationNameLegal()
+ {
+ var snippet = "animation : my-animation";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("my-animation", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationNameDurationDelayLegal()
+ {
+ var snippet = "animation : my-animation 2s 0.5s";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("2s 0.5s my-animation", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationNameDurationDelayEaseLegal()
+ {
+ var snippet = "animation : my-animation 200ms 0.5s ease";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("200ms ease 0.5s my-animation", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationCountDoubleIllegal()
+ {
+ var snippet = "animation : 10 20";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ // Two unitless numbers is ambiguous and should not parse successfully
+ // ("10 20ms" would be valid: 10 iterations, 20ms duration)
+ // But "10 20" with two unitless numbers has no clear interpretation
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void AnimationNameDurationCountEaseInOutLegal()
+ {
+ var snippet = "animation : my-animation 200ms 2.5 ease-in-out";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("200ms ease-in-out 2.5 my-animation", concrete.Value);
+ }
+
+ [TestMethod]
+ public void AnimationMultipleLegal()
+ {
+ var snippet = "animation : my-animation 0s 10 ease, other-animation 5 linear,yet-another 0s 1s 10 step-start !important";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("animation", property.Name);
+ Assert.IsTrue(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (AnimationProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("0s ease 10 my-animation, linear 5 other-animation, 0s step-start 1s 10 yet-another", concrete.Value);
+ }
+}
diff --git a/Source/Test/HtmlRenderer.Test/Css/AspectRatioGrammarTests.cs b/Source/Test/HtmlRenderer.Test/Css/AspectRatioGrammarTests.cs
new file mode 100644
index 000000000..ad4300bc0
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Css/AspectRatioGrammarTests.cs
@@ -0,0 +1,145 @@
+using HtmlRenderer.Test.CssEngineSupport;
+using TheArtOfDev.HtmlRenderer.Core.CssEngine;
+using TheArtOfDev.HtmlRenderer.Core.Parse;
+using System.Linq;
+
+namespace HtmlRenderer.Test.Css;
+
+///
+/// Ported from PeachPDF.Tests/CSS/AspectRatioGrammarTests.cs.
+/// Tests for the shared aspect-ratio value grammar
+/// [ auto || <ratio> ] ) and its Layer-A accept/reject via the full parser.
+///
+[TestClass]
+public sealed class AspectRatioGrammarTests
+{
+ private const double Delta = 1e-5;
+
+ private static bool TryParse(string value, out double? ratio) =>
+ AspectRatioGrammar.TryParse(CssValueParser.GetCssTokens(value), out ratio);
+
+ [TestMethod]
+ [DataRow("2", 2.0)]
+ [DataRow("16 / 9", 16.0 / 9.0)]
+ [DataRow("16/9", 16.0 / 9.0)]
+ [DataRow("1.5", 1.5)]
+ [DataRow("3 / 2", 1.5)]
+ [DataRow("auto 21 / 9", 21.0 / 9.0)]
+ [DataRow("21 / 9 auto", 21.0 / 9.0)]
+ public void ValidRatio_ParsesToWidthOverHeight(string value, double expected)
+ {
+ Assert.IsTrue(TryParse(value, out var ratio));
+ Assert.IsNotNull(ratio);
+ Assert.AreEqual(expected, ratio!.Value, Delta);
+ }
+
+ [TestMethod]
+ [DataRow("auto")]
+ [DataRow("1 / 0")] // a zero term => no usable ratio
+ [DataRow("0")]
+ [DataRow("0 / 5")]
+ public void AutoOrZeroTerm_IsValidButHasNoUsableRatio(string value)
+ {
+ Assert.IsTrue(TryParse(value, out var ratio));
+ Assert.IsNull(ratio);
+ }
+
+ [TestMethod]
+ [DataRow("")]
+ [DataRow("banana")]
+ [DataRow("2 3")] // two numbers without a slash
+ [DataRow("16 /")] // slash without a second number
+ [DataRow("/ 9")] // slash without a first number
+ [DataRow("-2")] // negative number
+ [DataRow("2 / -3")] // negative second term
+ [DataRow("auto auto")] // two autos
+ [DataRow("2px")] // a length, not a number
+ public void Invalid_ReturnsFalse(string value)
+ {
+ Assert.IsFalse(TryParse(value, out _));
+ }
+
+ // ─── hasAuto: distinguishing `auto ` (natural-ratio fallback) from a bare `` ───
+
+ private static bool TryParse(string value, out double? ratio, out bool hasAuto) =>
+ AspectRatioGrammar.TryParse(CssValueParser.GetCssTokens(value), out ratio, out hasAuto);
+
+ [TestMethod]
+ [DataRow("2", 2.0, false)] // bare ratio: overrides any natural ratio
+ [DataRow("16 / 9", 16.0 / 9.0, false)]
+ [DataRow("auto 16 / 9", 16.0 / 9.0, true)] // auto : prefer natural, fall back to 16/9
+ [DataRow("16 / 9 auto", 16.0 / 9.0, true)] // the `||` allows either order
+ public void HasAuto_DistinguishesAutoRatioFromBareRatio(string value, double expected, bool expectedAuto)
+ {
+ Assert.IsTrue(TryParse(value, out var ratio, out var hasAuto));
+ Assert.IsNotNull(ratio);
+ Assert.AreEqual(expected, ratio!.Value, Delta);
+ Assert.AreEqual(expectedAuto, hasAuto);
+ }
+
+ [TestMethod]
+ public void HasAuto_BareAuto_HasAutoTrueAndNullRatio()
+ {
+ Assert.IsTrue(TryParse("auto", out var ratio, out var hasAuto));
+ Assert.IsNull(ratio);
+ Assert.IsTrue(hasAuto);
+ }
+
+ [TestMethod]
+ [DataRow("aspect-ratio: 16 / 9", true)]
+ [DataRow("aspect-ratio: auto", true)]
+ [DataRow("aspect-ratio: 2", true)]
+ [DataRow("aspect-ratio: banana", false)]
+ [DataRow("aspect-ratio: 2px", false)]
+ public void LayerA_AcceptsValid_RejectsInvalid(string declaration, bool shouldApply)
+ {
+ var sheet = CssConstructionFunctions.ParseStyleSheet($"div {{ {declaration}; }}");
+ var style = sheet.Rules.OfType().Single().Style;
+ var applied = !string.IsNullOrEmpty(style.GetPropertyValue("aspect-ratio"));
+ Assert.AreEqual(shouldApply, applied);
+ }
+
+ // ─── TryParseRatio: the pure data type (no `auto`) used by @property ───
+
+ private static bool TryParseRatio(string value, out double? ratio) =>
+ AspectRatioGrammar.TryParseRatio(CssValueParser.GetCssTokens(value), out ratio);
+
+ [TestMethod]
+ [DataRow("16/9", 16.0 / 9.0)]
+ [DataRow("16 / 9", 16.0 / 9.0)]
+ [DataRow("1", 1.0)]
+ [DataRow("2", 2.0)]
+ [DataRow("3 / 2", 1.5)]
+ public void TryParseRatio_ValidRatio_ParsesToWidthOverHeight(string value, double expected)
+ {
+ Assert.IsTrue(TryParseRatio(value, out var ratio));
+ Assert.IsNotNull(ratio);
+ Assert.AreEqual(expected, ratio!.Value, Delta);
+ }
+
+ [TestMethod]
+ [DataRow("0/1")] // a zero term => valid, but no usable ratio
+ [DataRow("0")]
+ [DataRow("5 / 0")]
+ public void TryParseRatio_ZeroTerm_IsValidButHasNullRatio(string value)
+ {
+ Assert.IsTrue(TryParseRatio(value, out var ratio));
+ Assert.IsNull(ratio);
+ }
+
+ [TestMethod]
+ [DataRow("auto")] // — unlike aspect-ratio — does NOT permit `auto`
+ [DataRow("auto 16 / 9")]
+ [DataRow("16 / 9 auto")]
+ [DataRow("")]
+ [DataRow("banana")]
+ [DataRow("2 3")] // two numbers without a slash
+ [DataRow("16 /")] // slash without a second number
+ [DataRow("-2")] // negative number
+ [DataRow("2 / -3")] // negative second term
+ [DataRow("2px")] // a length, not a number
+ public void TryParseRatio_Invalid_ReturnsFalse(string value)
+ {
+ Assert.IsFalse(TryParseRatio(value, out _));
+ }
+}
diff --git a/Source/Test/HtmlRenderer.Test/Css/AtPropertyTests.cs b/Source/Test/HtmlRenderer.Test/Css/AtPropertyTests.cs
new file mode 100644
index 000000000..a06e6bc60
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Css/AtPropertyTests.cs
@@ -0,0 +1,98 @@
+using System.Linq;
+using HtmlRenderer.Test.CssEngineSupport;
+using TheArtOfDev.HtmlRenderer.Core.CssEngine;
+
+namespace HtmlRenderer.Test.Css;
+
+/// Ported from PeachPDF.Tests/CSS/AtPropertyTests.cs.
+[TestClass]
+public sealed class AtPropertyTests
+{
+ [TestMethod]
+ public void AtProperty_ParsesNameAndDescriptors()
+ {
+ var src = "@property --my-color { syntax: \"\"; inherits: false; initial-value: #c0ffee; }";
+ var sheet = CssConstructionFunctions.ParseStyleSheet(src);
+
+ Assert.IsNotNull(sheet);
+ var rule = sheet.Rules.OfType().Single();
+ Assert.AreEqual("--my-color", rule.Name);
+ StringAssert.Contains(rule.Syntax, "color");
+ Assert.AreEqual("false", rule.Inherits);
+ Assert.AreEqual("#c0ffee", rule.InitialValue);
+ }
+
+ [TestMethod]
+ public void AtProperty_UniversalSyntax_NoInitialValue()
+ {
+ var src = "@property --x { syntax: \"*\"; inherits: true; }";
+ var sheet = CssConstructionFunctions.ParseStyleSheet(src);
+
+ var rule = sheet.Rules.OfType().Single();
+ Assert.AreEqual("--x", rule.Name);
+ StringAssert.Contains(rule.Syntax, "*");
+ Assert.AreEqual("true", rule.Inherits);
+ Assert.AreEqual("", rule.InitialValue);
+ }
+
+ [TestMethod]
+ public void AtProperty_DoesNotDerailFollowingRules()
+ {
+ // Regression: an @property rule must not swallow or drop the rules that follow it. Before real
+ // @property parsing, the rule routed to CreateUnknown and (the whole point of this feature) was
+ // silently dropped; the following style rule must still parse and apply.
+ var src = "@property --gap { syntax: \"\"; inherits: false; initial-value: 4px; } .after { color: red; }";
+ var sheet = CssConstructionFunctions.ParseStyleSheet(src);
+
+ Assert.AreEqual(1, sheet.Rules.OfType().Count());
+ var styleRule = sheet.Rules.OfType().Single();
+ Assert.AreEqual(".after", styleRule.SelectorText);
+ // Named colors are normalized to rgb() at parse time.
+ Assert.AreEqual("rgb(255, 0, 0)", styleRule.Style.GetPropertyValue("color"));
+ }
+
+ [TestMethod]
+ public void AtProperty_NoDeclarationBlock_DoesNotCrashAndFollowingRuleApplies()
+ {
+ // A malformed @property with no { } block must be skipped without derailing the next rule.
+ var src = "@property --x; .after { color: red; }";
+ var sheet = CssConstructionFunctions.ParseStyleSheet(src);
+
+ var styleRule = sheet.Rules.OfType().Single();
+ Assert.AreEqual(".after", styleRule.SelectorText);
+ Assert.AreEqual("rgb(255, 0, 0)", styleRule.Style.GetPropertyValue("color"));
+ }
+
+ [TestMethod]
+ public void AtProperty_Setters_And_ToCss_RoundTrip()
+ {
+ // Start from a rule that only declares `syntax`, so setting initial-value/inherits exercises the
+ // create-new-descriptor path, and re-setting syntax exercises the replace-existing path.
+ var src = "@property --p { syntax: \"\"; }";
+ var rule = (PropertyRule)CssConstructionFunctions.ParseStyleSheet(src).Rules.OfType().Single();
+
+ rule.InitialValue = "1px"; // new descriptor
+ rule.Inherits = "true"; // new descriptor
+ rule.Syntax = "\"\""; // replace existing descriptor
+ StringAssert.Contains(rule.Syntax, "color");
+ Assert.AreEqual("1px", rule.InitialValue);
+ Assert.AreEqual("true", rule.Inherits);
+
+ var css = rule.ToCss();
+ StringAssert.Contains(css, "@property --p");
+ StringAssert.Contains(css, "initial-value");
+ }
+
+ [TestMethod]
+ public void AtProperty_MultipleRules_AllRegister()
+ {
+ var src = "@property --a { syntax: \"\"; inherits: false; initial-value: 0; }" +
+ "@property --b { syntax: \"\"; inherits: true; initial-value: 50%; }";
+ var sheet = CssConstructionFunctions.ParseStyleSheet(src);
+
+ var rules = sheet.Rules.OfType().ToList();
+ Assert.AreEqual(2, rules.Count);
+ Assert.AreEqual("--a", rules[0].Name);
+ Assert.AreEqual("--b", rules[1].Name);
+ }
+}
diff --git a/Source/Test/HtmlRenderer.Test/Css/BackgroundPropertyTests.cs b/Source/Test/HtmlRenderer.Test/Css/BackgroundPropertyTests.cs
new file mode 100644
index 000000000..e09ba0cae
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Css/BackgroundPropertyTests.cs
@@ -0,0 +1,991 @@
+using HtmlRenderer.Test.CssEngineSupport;
+using TheArtOfDev.HtmlRenderer.Core.CssEngine;
+
+namespace HtmlRenderer.Test.Css;
+
+/// Ported from PeachPDF.Tests/CSS/PropertyTests/BackgroundProperty.cs. Pure CSSOM parse tests - no layout involved.
+[TestClass]
+public sealed class BackgroundPropertyTests
+{
+ [TestMethod]
+ public void BackgroundAttachmentScrollLegal()
+ {
+ var snippet = "background-attachment : scroll";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-attachment", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundAttachmentProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("scroll", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundAttachmentInitialLegal()
+ {
+ var snippet = "background-attachment : initial";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-attachment", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundAttachmentProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("initial", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundAttachmentFixedUppercaseLegal()
+ {
+ var snippet = "background-attachment : Fixed ";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-attachment", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundAttachmentProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("fixed", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundAttachmentFixedLocalLegal()
+ {
+ var snippet = "background-attachment : fixed , local ";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-attachment", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundAttachmentProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("fixed, local", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundAttachmentFixedLocalScrollScrollLegal()
+ {
+ var snippet = "background-attachment : fixed , local,scroll,scroll ";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-attachment", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundAttachmentProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("fixed, local, scroll, scroll", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundAttachmentNoneIllegal()
+ {
+ var snippet = "background-attachment : none ";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-attachment", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundAttachmentProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BackgroundClipPaddingBoxUppercaseLegal()
+ {
+ var snippet = "background-clip : Padding-Box ";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-clip", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundClipProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("padding-box", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundClipPaddingBoxBorderBoxLegal()
+ {
+ var snippet = "background-clip : Padding-Box, border-box ";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-clip", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundClipProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("padding-box, border-box", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundClipContentBoxLegal()
+ {
+ var snippet = "background-clip : content-box";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-clip", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundClipProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("content-box", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundColorTealLegal()
+ {
+ var snippet = "background-color : teal";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-color", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundColorProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("rgb(0, 128, 128)", concrete.Value);
+ }
+
+ [TestMethod]
+ [DataRow("background-color: rgb(255, 255, 128)", "rgb(255, 255, 128)")]
+ [DataRow("background-color: hsla(50, 33%, 25%, 0.75)", "hsla(50deg, 33%, 25%, 0.75)")]
+ [DataRow("background-color : rgb(255 , 255 , 128)", "rgb(255, 255, 128)")]
+ [DataRow("background-color: Transparent", "rgba(0, 0, 0, 0)")]
+ [DataRow("background-color: #F09", "rgb(255, 0, 153)")]
+ [DataRow("background-color: #F09F", "rgb(255, 0, 153)")]
+ [DataRow("background-color: #AABBCC", "rgb(170, 187, 204)")]
+ [DataRow("background-color: #AABBCC11", "rgba(170, 187, 204, 0.07)")]
+ public void BackgroundColorRgbLegal(string snippet, string expectedValue)
+ {
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-color", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundColorProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual(expectedValue, concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundColorMultipleIllegal()
+ {
+ var snippet = "background-color : #bbff00, transparent, red, #ff00ff";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-color", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundColorProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BackgroundImageNoneLegal()
+ {
+ var snippet = "background-image: NONE";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("none", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundImageUrlAndNoneLegal()
+ {
+ var snippet = "background-image: url(\"img/sprites.svg?v=1bc768be1b3c\"),none";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"img/sprites.svg?v=1bc768be1b3c\"), none", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundImageUrlLegal()
+ {
+ var snippet = "background-image: url(image.png)";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"image.png\")", concrete.Value);
+ }
+
+ [TestMethod]
+ [DataRow("background-image: image-set(\"a.png\" 1x, \"b.png\" 2x)")]
+ [DataRow("background-image: cross-fade(url(a.png), url(b.png), 50%)")]
+ [DataRow("background-image: element(#hero)")]
+ public void BackgroundImageExtendedFunctionLegal(string snippet)
+ {
+ // image-set()/cross-fade()/element() are valid values (CSS Images 4) and now parse via the
+ // shared ImageSourceConverter, even though PeachPDF renders nothing for them (issue #229 gap 3).
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-image", property.Name);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundImageProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.IsFalse(string.IsNullOrEmpty(concrete.Value)); // serializes back through ImageFunctionValue.CssText
+ }
+
+ [TestMethod]
+ [DataRow("background-image: image-set(banana)")]
+ [DataRow("background-image: element(.klass)")]
+ [DataRow("background-image: cross-fade(5px)")]
+ public void BackgroundImageMalformedExtendedFunctionIllegal(string snippet)
+ {
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.IsFalse(((BackgroundImageProperty)property).HasValue);
+ }
+
+ [TestMethod]
+ public void BackgroundImageUrlAbsoluteLegal()
+ {
+ var snippet = "background-image: url(http://www.example.com/images/bck.png)";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"http://www.example.com/images/bck.png\")", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundImageUrlsLegal()
+ {
+ var snippet = "background-image: url(image.png),url('bla.png')";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"image.png\"), url(\"bla.png\")", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundImageUrlNoneUrlLegal()
+ {
+ var snippet = "background-image: url(image.png),none, url(foo.gif)";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"image.png\"), none, url(\"foo.gif\")", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundOriginContentBoxLegal()
+ {
+ var snippet = "background-origin: CONTENT-BOX";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-origin", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundOriginProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("content-box", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundOriginContentBoxPaddingBoxLegal()
+ {
+ var snippet = "background-origin: CONTENT-BOX, Padding-Box";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-origin", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundOriginProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("content-box, padding-box", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundOriginBorderBoxLegal()
+ {
+ var snippet = "background-origin: border-box";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-origin", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundOriginProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("border-box", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundPositionTopLegal()
+ {
+ var snippet = "background-position: top";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-position", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundPositionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("top", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundPositionPercentPercentLegal()
+ {
+ var snippet = "background-position: 25% 75%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-position", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundPositionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("25% 75%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundPositionCenterPercentLegal()
+ {
+ var snippet = "background-position: center 75%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-position", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundPositionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("center 75%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundPositionRightLengthBottomLengthLegal()
+ {
+ var snippet = "background-position: right 20px bottom 20px";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-position", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundPositionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("right 20px bottom 20px", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundPositionLengthLengthCenterMultipleLegal()
+ {
+ var snippet = "background-position: 10px 20px, center";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-position", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundPositionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10px 20px, center", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundPositionZeroMultipleLegal()
+ {
+ var snippet = "background-position: 0 0, 0 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-position", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundPositionProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("0 0, 0 0", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundRepeatRepeatXLegal()
+ {
+ var snippet = "background-repeat: repeat-x";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("repeat-x", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundRepeatRepeatYLegal()
+ {
+ var snippet = "background-repeat: repeat-y";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("repeat-y", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundRepeatRepeatLegal()
+ {
+ var snippet = "background-repeat: REPEAT";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("repeat", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundRepeatRoundLegal()
+ {
+ var snippet = "background-repeat: rounD";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("round", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundRepeatRepeatSpaceLegal()
+ {
+ var snippet = "background-repeat: repeat space";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("repeat space", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundRepeatRepeatXSpaceIllegal()
+ {
+ var snippet = "background-repeat: repeat-x space";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BackgroundRepeatRepeatXRepeatYMultipleLegal()
+ {
+ var snippet = "background-repeat: repeat-X, repeat-Y";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("repeat-x, repeat-y", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundRepeatSpaceRoundLegal()
+ {
+ var snippet = "background-repeat: space round";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("space round", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundRepeatNoRepeatRepeatXIllegal()
+ {
+ var snippet = "background-repeat: no-repeat repeat-x";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BackgroundRepeatRepeatRepeatNoRepeatRepeatLegal()
+ {
+ var snippet = "background-repeat: repeat repeat, no-repeat repeat";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("repeat repeat, no-repeat repeat", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundSizeLengthLegal()
+ {
+ var snippet = "background-size: 2em";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-size", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundSizeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("2em", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundSizePercentLegal()
+ {
+ var snippet = "background-size: 20%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-size", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundSizeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("20%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundSizeAutoAutoLegal()
+ {
+ var snippet = "background-size: auto auto";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-size", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundSizeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("auto auto", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundSizeAutoLengthLegal()
+ {
+ var snippet = "background-size: auto 50px";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-size", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundSizeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("auto 50px", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundSizeLengthLengthLegal()
+ {
+ var snippet = "background-size: 25px 50px";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-size", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundSizeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("25px 50px", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundSizePercentPercentLegal()
+ {
+ var snippet = "background-size: 50% 50%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-size", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundSizeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("50% 50%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundSizeAutoUppercaseLegal()
+ {
+ var snippet = "background-size: AUTO";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-size", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundSizeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("auto", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundSizeCoverLegal()
+ {
+ var snippet = "background-size: cover";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-size", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundSizeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("cover", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundSizeContainCoverMultipleLegal()
+ {
+ var snippet = "background-size: contain,cover";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-size", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundSizeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("contain, cover", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundSizeContainLengthAutoPercentLegal()
+ {
+ var snippet = "background-size: contain,100px,auto,20%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-size", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundSizeProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("contain, 100px, auto, 20%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundRedLegal()
+ {
+ var snippet = "background: red";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("rgb(255, 0, 0)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundWhiteImageLegal()
+ {
+ var snippet = "background: white url(\"pendant.png\");";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"pendant.png\") rgb(255, 255, 255)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundImageLegal()
+ {
+ var snippet = "background: url(\"topbanner.png\") #00d repeat-y fixed";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"topbanner.png\") repeat-y fixed rgb(0, 0, 221)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundWithoutColorLegal()
+ {
+ var snippet = "background: url(\"img_tree.png\") no-repeat right top";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"img_tree.png\") right top no-repeat", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundImageDataUrlLegal()
+ {
+ var url = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEcAAAAcCAMAAAAEJ1IZAAAABGdBTUEAALGPC/xhBQAAVAI/VAI/VAI/VAI/VAI/VAI/VAAAA////AI/VRZ0U8AAAAFJ0Uk5TYNV4S2UbgT/Gk6uQt585w2wGXS0zJO2lhGttJK6j4YqZSobH1AAAAAElFTkSuQmCC";
+ var snippet = "background-image: url('" + url + "')";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"" + url + "\")", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundTransparentLegal()
+ {
+ var snippet = "background: transparent";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("rgba(0, 0, 0, 0)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundNoneLegal()
+ {
+ var snippet = "background: none";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("none", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundWithPositionLegal()
+ {
+ var snippet = "background: url(\"img.png\") center center no-repeat";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BackgroundWithPositionAndSizeLegal()
+ {
+ var snippet = "background: url(\"img.png\") center / cover no-repeat";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BackgroundLinearGradientLegal()
+ {
+ var snippet = "background: linear-gradient(to right, red, blue)";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ StringAssert.Contains(concrete.Value, "linear-gradient");
+ }
+
+ [TestMethod]
+ public void BackgroundHexColorLegal()
+ {
+ var snippet = "background: #ff0000";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("rgb(255, 0, 0)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundRgbaColorLegal()
+ {
+ var snippet = "background: rgba(0, 128, 255, 0.5)";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("rgba(0, 128, 255, 0.5)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundWithRepeatXLegal()
+ {
+ var snippet = "background: url(\"tile.png\") repeat-x top";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ }
+
+ [TestMethod]
+ [DataRow("background: red", "rgb(255, 0, 0)")]
+ [DataRow("background: white url(\"pendant.png\")", "url(\"pendant.png\") rgb(255, 255, 255)")]
+ [DataRow("background: url(\"topbanner.png\") #00d repeat-y fixed", "url(\"topbanner.png\") repeat-y fixed rgb(0, 0, 221)")]
+ [DataRow("background: url(\"img_tree.png\") no-repeat right top", "url(\"img_tree.png\") right top no-repeat")]
+ public void BackgroundShorthandValues(string snippet, string expectedValue)
+ {
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("background", property.Name);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BackgroundProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual(expectedValue, concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundShorthand_Color_SetsBackgroundColor()
+ {
+ var style = CssConstructionFunctions.ParseDeclarations("background: red");
+ Assert.AreEqual("rgb(255, 0, 0)", style.BackgroundColor);
+ Assert.AreEqual("initial", style.BackgroundImage);
+ Assert.AreEqual("initial", style.BackgroundRepeat);
+ Assert.AreEqual("initial", style.BackgroundPosition);
+ Assert.AreEqual("initial", style.BackgroundSize);
+ Assert.AreEqual("initial", style.BackgroundAttachment);
+ }
+
+ [TestMethod]
+ public void BackgroundShorthand_Transparent_SetsBackgroundColorToTransparent()
+ {
+ var style = CssConstructionFunctions.ParseDeclarations("background: transparent");
+ Assert.AreEqual("rgba(0, 0, 0, 0)", style.BackgroundColor);
+ Assert.AreEqual("initial", style.BackgroundImage);
+ }
+
+ [TestMethod]
+ public void BackgroundShorthand_ImageAndColor_SetsBothLonghands()
+ {
+ var style = CssConstructionFunctions.ParseDeclarations("background: white url(\"pendant.png\")");
+ Assert.AreEqual("rgb(255, 255, 255)", style.BackgroundColor);
+ Assert.AreEqual("url(\"pendant.png\")", style.BackgroundImage);
+ Assert.AreEqual("initial", style.BackgroundRepeat);
+ Assert.AreEqual("initial", style.BackgroundPosition);
+ }
+
+ [TestMethod]
+ public void BackgroundShorthand_ImageRepeatAttachmentColor_SetsAllFourLonghands()
+ {
+ var style = CssConstructionFunctions.ParseDeclarations("background: url(\"topbanner.png\") #00d repeat-y fixed");
+ Assert.AreEqual("rgb(0, 0, 221)", style.BackgroundColor);
+ Assert.AreEqual("url(\"topbanner.png\")", style.BackgroundImage);
+ Assert.AreEqual("repeat-y", style.BackgroundRepeat);
+ Assert.AreEqual("fixed", style.BackgroundAttachment);
+ Assert.AreEqual("initial", style.BackgroundPosition);
+ }
+
+ [TestMethod]
+ public void BackgroundShorthand_ImageNoRepeatPosition_SetsImageRepeatPosition()
+ {
+ var style = CssConstructionFunctions.ParseDeclarations("background: url(\"img_tree.png\") no-repeat right top");
+ Assert.AreEqual("url(\"img_tree.png\")", style.BackgroundImage);
+ Assert.AreEqual("no-repeat", style.BackgroundRepeat);
+ Assert.AreEqual("right top", style.BackgroundPosition);
+ Assert.AreEqual("initial", style.BackgroundColor);
+ }
+
+ [TestMethod]
+ public void BackgroundShorthand_LinearGradient_SetsBackgroundImage()
+ {
+ var style = CssConstructionFunctions.ParseDeclarations("background: linear-gradient(to right, red, blue)");
+ StringAssert.Contains(style.BackgroundImage, "linear-gradient");
+ Assert.AreEqual("initial", style.BackgroundColor);
+ }
+
+ [TestMethod]
+ public void BackgroundShorthand_ImagePositionSize_SetsPositionAndSize()
+ {
+ var style = CssConstructionFunctions.ParseDeclarations("background: url(\"img.png\") center / cover no-repeat");
+ Assert.AreEqual("url(\"img.png\")", style.BackgroundImage);
+ Assert.AreEqual("center", style.BackgroundPosition);
+ Assert.AreEqual("cover", style.BackgroundSize);
+ Assert.AreEqual("no-repeat", style.BackgroundRepeat);
+ }
+
+ [TestMethod]
+ public void BackgroundShorthand_MultipleLayers_ExtractsCommaJoinedNotSpaceJoinedLonghands()
+ {
+ // Regression test: EndListValueConverter used to join per-layer longhand values with a
+ // space instead of a comma when extracted from a multi-layer `background` shorthand,
+ // silently corrupting them (e.g. "no-repeat repeat-x" looks like a single valid
+ // two-axis repeat value, not two layers).
+ var style = CssConstructionFunctions.ParseDeclarations(
+ "background: url(\"a.png\") top no-repeat, url(\"b.png\") bottom repeat-x");
+
+ Assert.AreEqual("url(\"a.png\"), url(\"b.png\")", style.BackgroundImage);
+ Assert.AreEqual("top, bottom", style.BackgroundPosition);
+ Assert.AreEqual("no-repeat, repeat-x", style.BackgroundRepeat);
+ Assert.AreNotEqual("no-repeat repeat-x", style.BackgroundRepeat);
+ }
+
+ [TestMethod]
+ public void BackgroundShorthand_MultipleLayers_OriginClipCommaJoined()
+ {
+ // Each layer explicitly gives both box-model keywords (origin then clip) to avoid a
+ // separate, pre-existing ambiguity in this shorthand: a single box-model keyword is
+ // always assigned to background-origin (never background-clip) here, rather than
+ // setting both per spec - unrelated to the comma-vs-whitespace joining this test targets.
+ var style = CssConstructionFunctions.ParseDeclarations(
+ "background: url(\"a.png\") padding-box content-box, url(\"b.png\") border-box padding-box");
+
+ Assert.AreEqual("url(\"a.png\"), url(\"b.png\")", style.BackgroundImage);
+ Assert.AreEqual("padding-box, border-box", style.BackgroundOrigin);
+ Assert.AreEqual("content-box, padding-box", style.BackgroundClip);
+ }
+
+ [TestMethod]
+ public void BackgroundShorthand_HexColor_SetsBackgroundColor()
+ {
+ var style = CssConstructionFunctions.ParseDeclarations("background: #336699");
+ Assert.AreEqual("rgb(51, 102, 153)", style.BackgroundColor);
+ Assert.AreEqual("initial", style.BackgroundImage);
+ }
+
+ [TestMethod]
+ public void BackgroundShorthand_None_SetsBackgroundImageToNone()
+ {
+ var style = CssConstructionFunctions.ParseDeclarations("background: none");
+ Assert.AreEqual("none", style.BackgroundImage);
+ Assert.AreEqual("initial", style.BackgroundColor);
+ }
+}
diff --git a/Source/Test/HtmlRenderer.Test/Css/BasicShapeGrammarTests.cs b/Source/Test/HtmlRenderer.Test/Css/BasicShapeGrammarTests.cs
new file mode 100644
index 000000000..c30629cc8
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Css/BasicShapeGrammarTests.cs
@@ -0,0 +1,312 @@
+using System.Linq;
+using HtmlRenderer.Test.CssEngineSupport;
+using TheArtOfDev.HtmlRenderer.Core.CssEngine;
+using TheArtOfDev.HtmlRenderer.Core.Parse;
+
+namespace HtmlRenderer.Test.Css;
+
+///
+/// Ported from PeachPDF.Tests/CSS/BasicShapeGrammarTests.cs.
+/// Tests for the shared polygon()/inset()/circle()/ellipse() basic-shape grammar) and the clip-path
+/// Layer-A converter (
+[TestClass]
+public sealed class BasicShapeGrammarTests
+{
+ private static BasicShapeGrammar.ParsedBasicShape Parse(string value) =>
+ BasicShapeGrammar.TryParse(CssValueParser.GetCssTokens(value));
+
+ // ─── polygon() ─────────────────────────────────────────────────────────
+
+ [TestMethod]
+ public void Polygon_ThreePoints_ParsesWithDefaultNonzeroFill()
+ {
+ var shape = Parse("polygon(0 0, 100% 0, 50% 100%)");
+
+ Assert.IsNotNull(shape);
+ Assert.AreEqual(BasicShapeGrammar.BasicShapeKind.Polygon, shape.Kind);
+ Assert.AreEqual(BasicShapeGrammar.FillRule.Nonzero, shape.PolygonFillRule);
+ Assert.AreEqual(3, shape.PolygonPoints.Count);
+ Assert.AreEqual(("0", "0"), (shape.PolygonPoints[0].X, shape.PolygonPoints[0].Y));
+ Assert.AreEqual(("100%", "0"), (shape.PolygonPoints[1].X, shape.PolygonPoints[1].Y));
+ Assert.AreEqual(("50%", "100%"), (shape.PolygonPoints[2].X, shape.PolygonPoints[2].Y));
+ }
+
+ [TestMethod]
+ [DataRow("polygon(evenodd, 0 0, 10px 0, 0 10px)", true)]
+ [DataRow("polygon(nonzero, 0 0, 10px 0, 0 10px)", false)]
+ public void Polygon_ExplicitFillRule_IsCaptured(string value, bool expectEvenodd)
+ {
+ var shape = Parse(value);
+
+ Assert.IsNotNull(shape);
+ var expected = expectEvenodd ? BasicShapeGrammar.FillRule.Evenodd : BasicShapeGrammar.FillRule.Nonzero;
+ Assert.AreEqual(expected, shape.PolygonFillRule);
+ Assert.AreEqual(3, shape.PolygonPoints.Count);
+ }
+
+ [TestMethod]
+ public void Polygon_CalcComponent_IsAcceptedAndPreserved()
+ {
+ // A calc()-family expression is a valid polygon vertex component
+ // (resolved at render time). The whole shape must stay valid and the calc text preserved.
+ var shape = Parse("polygon(0% calc(100% * 0.65), 100% 100%, 0% 100%)");
+
+ Assert.IsNotNull(shape);
+ Assert.AreEqual(BasicShapeGrammar.BasicShapeKind.Polygon, shape.Kind);
+ Assert.AreEqual(3, shape.PolygonPoints.Count);
+ Assert.AreEqual("0%", shape.PolygonPoints[0].X);
+ Assert.IsTrue(shape.PolygonPoints[0].Y.StartsWith("calc("));
+ Assert.IsTrue(shape.PolygonPoints[0].Y.Contains("0.65"));
+ Assert.AreEqual(("100%", "100%"), (shape.PolygonPoints[1].X, shape.PolygonPoints[1].Y));
+ Assert.AreEqual(("0%", "100%"), (shape.PolygonPoints[2].X, shape.PolygonPoints[2].Y));
+ }
+
+ [TestMethod]
+ [DataRow("polygon(min(10px, 20px) 0, 100% 0, 0 100%)")]
+ [DataRow("polygon(0 max(10%, 5px), 100% 0, 0 100%)")]
+ [DataRow("polygon(clamp(0px, 50%, 100px) 0, 100% 0, 0 100%)")]
+ public void Polygon_CalcFamilyFunctions_AreAccepted(string value)
+ {
+ var shape = Parse(value);
+ Assert.IsNotNull(shape);
+ Assert.AreEqual(3, shape.PolygonPoints.Count);
+ }
+
+ [TestMethod]
+ public void Polygon_SinglePoint_IsValid()
+ {
+ var shape = Parse("polygon(50% 50%)");
+
+ Assert.IsNotNull(shape);
+ Assert.AreEqual(1, shape.PolygonPoints.Count);
+ }
+
+ [TestMethod]
+ [DataRow("polygon()")] // no points
+ [DataRow("polygon(0)")] // odd token count in a pair
+ [DataRow("polygon(0 0, 100%)")] // second pair incomplete
+ [DataRow("polygon(banana, 0 0)")] // bad fill-rule ident
+ [DataRow("polygon(evenodd)")] // fill-rule but no points
+ [DataRow("polygon(0 0,, 10px 10px)")] // empty middle group
+ [DataRow("polygon(red 0, 10px 0)")] // non-length component
+ public void Polygon_Malformed_ReturnsNull(string value)
+ {
+ Assert.IsNull(Parse(value));
+ }
+
+ // ─── inset() ───────────────────────────────────────────────────────────
+
+ [TestMethod]
+ [DataRow("inset(10px)", "10px", "10px", "10px", "10px")]
+ [DataRow("inset(10px 20px)", "10px", "20px", "10px", "20px")]
+ [DataRow("inset(10px 20px 30px)", "10px", "20px", "30px", "20px")]
+ [DataRow("inset(1px 2px 3px 4px)", "1px", "2px", "3px", "4px")]
+ public void Inset_ShorthandFill_ExpandsToTopRightBottomLeft(string value, string top, string right, string bottom, string left)
+ {
+ var shape = Parse(value);
+
+ Assert.IsNotNull(shape);
+ Assert.AreEqual(BasicShapeGrammar.BasicShapeKind.Inset, shape.Kind);
+ CollectionAssert.AreEqual(new[] { top, right, bottom, left }, shape.InsetEdges.ToArray());
+ Assert.IsFalse(shape.InsetHasRound);
+ }
+
+ [TestMethod]
+ public void Inset_WithRound_CapturesRadiusButFlagsRound()
+ {
+ var shape = Parse("inset(10px round 5px)");
+
+ Assert.IsNotNull(shape);
+ CollectionAssert.AreEqual(new[] { "10px", "10px", "10px", "10px" }, shape.InsetEdges.ToArray());
+ Assert.IsTrue(shape.InsetHasRound);
+ Assert.IsTrue(shape.InsetRoundRadius.Count > 0);
+ }
+
+ [TestMethod]
+ public void Inset_PercentageEdges_AreValid()
+ {
+ var shape = Parse("inset(10% 20%)");
+
+ Assert.IsNotNull(shape);
+ CollectionAssert.AreEqual(new[] { "10%", "20%", "10%", "20%" }, shape.InsetEdges.ToArray());
+ }
+
+ [TestMethod]
+ [DataRow("inset()")] // no offsets
+ [DataRow("inset(1px 2px 3px 4px 5px)")] // more than 4 offsets
+ [DataRow("inset(10px round)")] // round with no radius
+ [DataRow("inset(red)")] // non-length offset
+ public void Inset_Malformed_ReturnsNull(string value)
+ {
+ Assert.IsNull(Parse(value));
+ }
+
+ // ─── circle() ──────────────────────────────────────────────────────────
+
+ [TestMethod]
+ public void Circle_Empty_DefaultsClosestSideAndCenter()
+ {
+ var shape = Parse("circle()");
+
+ Assert.IsNotNull(shape);
+ Assert.AreEqual(BasicShapeGrammar.BasicShapeKind.Circle, shape.Kind);
+ Assert.AreEqual(BasicShapeGrammar.ShapeRadiusKind.ClosestSide, shape.RadiusX.Kind);
+ Assert.AreEqual("50%", shape.CenterX);
+ Assert.AreEqual("50%", shape.CenterY);
+ }
+
+ [TestMethod]
+ public void Circle_FarthestSide_Keyword()
+ {
+ var shape = Parse("circle(farthest-side)");
+
+ Assert.IsNotNull(shape);
+ Assert.AreEqual(BasicShapeGrammar.ShapeRadiusKind.FarthestSide, shape.RadiusX.Kind);
+ }
+
+ [TestMethod]
+ public void Circle_ExplicitRadius_AndPosition()
+ {
+ var shape = Parse("circle(50px at 10px 20px)");
+
+ Assert.IsNotNull(shape);
+ Assert.AreEqual(BasicShapeGrammar.ShapeRadiusKind.LengthPercentage, shape.RadiusX.Kind);
+ Assert.AreEqual("50px", shape.RadiusX.Length);
+ Assert.AreEqual("10px", shape.CenterX);
+ Assert.AreEqual("20px", shape.CenterY);
+ }
+
+ [TestMethod]
+ public void Circle_PositionKeywords_ResolveToPercentages()
+ {
+ var shape = Parse("circle(closest-side at left top)");
+
+ Assert.IsNotNull(shape);
+ Assert.AreEqual("0%", shape.CenterX);
+ Assert.AreEqual("0%", shape.CenterY);
+ }
+
+ [TestMethod]
+ public void Circle_PositionRightBottom_ResolveToHundredPercent()
+ {
+ var shape = Parse("circle(at right bottom)");
+
+ Assert.IsNotNull(shape);
+ Assert.AreEqual("100%", shape.CenterX);
+ Assert.AreEqual("100%", shape.CenterY);
+ }
+
+ [TestMethod]
+ [DataRow("circle(10px 20px)")] // two radii (that's ellipse)
+ [DataRow("circle(at)")] // "at" with no position
+ [DataRow("circle(banana)")] // junk radius
+ [DataRow("circle(-5px)")] // negative is invalid
+ [DataRow("circle(-10% at center)")]
+ [DataRow("ellipse(-5px 10px)")] // a negative axis radius invalidates the whole shape
+ public void Circle_Malformed_ReturnsNull(string value)
+ {
+ Assert.IsNull(Parse(value));
+ }
+
+ // ─── ellipse() ─────────────────────────────────────────────────────────
+
+ [TestMethod]
+ public void Ellipse_Empty_DefaultsBothRadiiClosestSide()
+ {
+ var shape = Parse("ellipse()");
+
+ Assert.IsNotNull(shape);
+ Assert.AreEqual(BasicShapeGrammar.BasicShapeKind.Ellipse, shape.Kind);
+ Assert.AreEqual(BasicShapeGrammar.ShapeRadiusKind.ClosestSide, shape.RadiusX.Kind);
+ Assert.AreEqual(BasicShapeGrammar.ShapeRadiusKind.ClosestSide, shape.RadiusY.Kind);
+ }
+
+ [TestMethod]
+ public void Ellipse_TwoRadii_AndPosition()
+ {
+ var shape = Parse("ellipse(40px 20% at 25% 75%)");
+
+ Assert.IsNotNull(shape);
+ Assert.AreEqual("40px", shape.RadiusX.Length);
+ Assert.AreEqual("20%", shape.RadiusY.Length);
+ Assert.AreEqual("25%", shape.CenterX);
+ Assert.AreEqual("75%", shape.CenterY);
+ }
+
+ [TestMethod]
+ public void Ellipse_MixedKeywordRadii()
+ {
+ var shape = Parse("ellipse(closest-side farthest-side at right bottom)");
+
+ Assert.IsNotNull(shape);
+ Assert.AreEqual(BasicShapeGrammar.ShapeRadiusKind.ClosestSide, shape.RadiusX.Kind);
+ Assert.AreEqual(BasicShapeGrammar.ShapeRadiusKind.FarthestSide, shape.RadiusY.Kind);
+ Assert.AreEqual("100%", shape.CenterX);
+ Assert.AreEqual("100%", shape.CenterY);
+ }
+
+ [TestMethod]
+ [DataRow("ellipse(40px)")] // exactly one radius is invalid
+ [DataRow("ellipse(40px 20px 10px)")] // three radii
+ public void Ellipse_Malformed_ReturnsNull(string value)
+ {
+ Assert.IsNull(Parse(value));
+ }
+
+ // ─── top-level rejection ────────────────────────────────────────────────
+
+ [TestMethod]
+ [DataRow("none")]
+ [DataRow("banana")]
+ [DataRow("url(#clip)")]
+ [DataRow("rect(0 0 0 0)")]
+ public void NonBasicShape_ReturnsNull(string value)
+ {
+ Assert.IsNull(Parse(value));
+ }
+
+ // ─── Layer A: converter accept/reject via the parser ────────────────────
+
+ [TestMethod]
+ [DataRow("none")]
+ [DataRow("polygon(0 0, 100% 0, 50% 100%)")]
+ [DataRow("inset(10px 20px round 4px)")]
+ [DataRow("circle(50px at center)")]
+ [DataRow("ellipse(closest-side farthest-side)")]
+ public void ClipPath_ValidValue_SurvivesParsing(string value)
+ {
+ var property = CssConstructionFunctions.ParseDeclaration($"clip-path: {value}");
+
+ Assert.IsInstanceOfType(property);
+ var concrete = (ClipPathProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ // Authored text is preserved verbatim for the render layer to re-parse.
+ Assert.AreEqual(value, concrete.Value);
+ }
+
+ [TestMethod]
+ [DataRow("banana")]
+ [DataRow("polygon(0)")]
+ [DataRow("circle(10px 20px)")]
+ public void ClipPath_InvalidValue_IsDropped(string value)
+ {
+ var property = CssConstructionFunctions.ParseDeclaration($"clip-path: {value}");
+
+ Assert.IsInstanceOfType(property);
+ Assert.IsFalse(((ClipPathProperty)property).HasValue);
+ }
+
+ [TestMethod]
+ public void ClipPath_InStyleSheet_ValidSurvives_InvalidDropped()
+ {
+ var valid = CssConstructionFunctions.ParseStyleSheet("div{clip-path:polygon(0 0, 100% 0, 50% 100%)}");
+ var validRule = valid.Rules.OfType().Single();
+ Assert.AreEqual("polygon(0 0, 100% 0, 50% 100%)", validRule.Style.GetPropertyValue("clip-path"));
+
+ var invalid = CssConstructionFunctions.ParseStyleSheet("div{clip-path:banana}");
+ var invalidRule = invalid.Rules.OfType().Single();
+ Assert.AreEqual(string.Empty, invalidRule.Style.GetPropertyValue("clip-path"));
+ }
+}
diff --git a/Source/Test/HtmlRenderer.Test/Css/BorderImagePropertyTests.cs b/Source/Test/HtmlRenderer.Test/Css/BorderImagePropertyTests.cs
new file mode 100644
index 000000000..b130ed185
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Css/BorderImagePropertyTests.cs
@@ -0,0 +1,498 @@
+using HtmlRenderer.Test.CssEngineSupport;
+using TheArtOfDev.HtmlRenderer.Core.CssEngine;
+
+namespace HtmlRenderer.Test.Css;
+
+/// Ported from PeachPDF.Tests/CSS/PropertyTests/BorderImageProperty.cs. Pure CSSOM parse tests - no layout involved.
+[TestClass]
+public sealed class BorderImagePropertyTests
+{
+ [TestMethod]
+ public void BorderImageSourceNoneLegal()
+ {
+ var snippet = "border-image-source: none ";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-source", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageSourceProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("none", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageSourceUrlLegal()
+ {
+ var snippet = "border-image-source: url(image.jpg)";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-source", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageSourceProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"image.jpg\")", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageSourceLinearGradientLegal()
+ {
+ var snippet = "border-image-source: linear-gradient(to top, red, yellow)";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-source", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageSourceProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("linear-gradient(to top, rgb(255, 0, 0), rgb(255, 255, 0))", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageOutsetZeroLegal()
+ {
+ var snippet = "border-image-outset: 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-outset", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageOutsetProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("0", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageOutsetLengthPercentLegal()
+ {
+ var snippet = "border-image-outset: 10px 25%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-outset", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageOutsetProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10px 25%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageOutsetLengthPercentZeroLegal()
+ {
+ var snippet = "border-image-outset: 10px 25% 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-outset", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageOutsetProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10px 25% 0", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageOutsetLengthPercentZeroPercentLegal()
+ {
+ var snippet = "border-image-outset: 10px 25% 0 10%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-outset", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageOutsetProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10px 25% 0 10%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageOutsetZerosIllegal()
+ {
+ var snippet = "border-image-outset: 0 0 0 0 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-outset", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageOutsetProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BorderImageWidthZeroLegal()
+ {
+ var snippet = "border-image-width: 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-width", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageWidthProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("0", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageWidthAutoLegal()
+ {
+ var snippet = "border-image-width: auto";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-width", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageWidthProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("auto", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageWidthMultipleLegal()
+ {
+ var snippet = "border-image-width: 5";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-width", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageWidthProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("5", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageWidthLengthPercentLegal()
+ {
+ var snippet = "border-image-width: 10px 25%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-width", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageWidthProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10px 25%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageWidthLengthPercentZeroLegal()
+ {
+ var snippet = "border-image-width: 10px 25% 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-width", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageWidthProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10px 25% 0", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageWidthLengthPercentAutoPercentLegal()
+ {
+ var snippet = "border-image-width: 10px 25% auto 10%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-width", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageWidthProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10px 25% auto 10%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageWidthZerosIllegal()
+ {
+ var snippet = "border-image-width: 0 0 0 0 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-width", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageWidthProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BorderImageRepeatStretchUppercaseLegal()
+ {
+ var snippet = "border-image-repeat: StRETCH";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("stretch", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageRepeatRepeatLegal()
+ {
+ var snippet = "border-image-repeat: repeat";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("repeat", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageRepeatRoundLegal()
+ {
+ var snippet = "border-image-repeat: round";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("round", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageRepeatStretchRoundLegal()
+ {
+ var snippet = "border-image-repeat: stretch round";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("stretch round", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageRepeatNoRepeatIllegal()
+ {
+ var snippet = "border-image-repeat: no-repeat";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-repeat", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageRepeatProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BorderImageSlicePixelsLegal()
+ {
+ var snippet = "border-image-slice: 3";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-slice", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageSliceProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("3", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageSlicePercentLegal()
+ {
+ var snippet = "border-image-slice: 10%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-slice", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageSliceProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageSliceFillLegal()
+ {
+ var snippet = "border-image-slice: fill";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-slice", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageSliceProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ //Assert.AreEqual(true, concrete.IsFilled);
+ //Assert.AreEqual(Length.Full, concrete.SliceLeft);
+ //Assert.AreEqual(Length.Full, concrete.SliceRight);
+ //Assert.AreEqual(Length.Full, concrete.SliceTop);
+ //Assert.AreEqual(Length.Full, concrete.SliceBottom);
+ }
+
+ [TestMethod]
+ public void BorderImageSlicePercentFillLegal()
+ {
+ var snippet = "border-image-slice: 10% fill";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-slice", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageSliceProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10% fill", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageSlicePercentPixelsFillLegal()
+ {
+ var snippet = "border-image-slice: 10% 30 fill";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-slice", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageSliceProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10% 30 fill", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageSlicePercentPixelsFillZerosLegal()
+ {
+ var snippet = "border-image-slice: 10% 30 fill 0 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-slice", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageSliceProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10% 30 0 0 fill", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageSlicePercentPixelsFillZerosIllegal()
+ {
+ var snippet = "border-image-slice: 10% 30 fill 0 0 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-slice", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageSliceProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BorderImageSlicePercentPixelsZerosFillIllegal()
+ {
+ var snippet = "border-image-slice: 10% 30 0 0 0 fill";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image-slice", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageSliceProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BorderImageNoneLegal()
+ {
+ var snippet = "border-image: none ";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("none", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageUrlOffsetLegal()
+ {
+ var snippet = "border-image: url(image.png) 50 50";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"image.png\") 50 50", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageUrlOffsetRepeatLegal()
+ {
+ var snippet = "border-image: url(image.png) 30 30 repeat";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"image.png\") 30 30 repeat", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageUrlStretchUppercaseLegal()
+ {
+ var snippet = "border-image: url(image.png) STRETCH";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"image.png\") stretch", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageUrlOffsetWidthTwoLegal()
+ {
+ var snippet = "border-image: url(image.png) 30 30 / 15px 15px";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"image.png\") 30 30 / 15px", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageUrlOffsetWidthFourLegal()
+ {
+ var snippet = "border-image: url(image.png) 30 30 0 10 / 15px 0 15px 2em";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"image.png\") 30 30 0 10 / 15px 0 15px 2em", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderImageUrlOffsetWidthOutsetLegal()
+ {
+ var snippet = "border-image: url(image.png) 30 30 / 15px 15px / 5% 2% 0 10%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-image", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderImageProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("url(\"image.png\") 30 30 / 15px / 5% 2% 0 10%", concrete.Value);
+ }
+}
diff --git a/Source/Test/HtmlRenderer.Test/Css/BorderPropertyTests.cs b/Source/Test/HtmlRenderer.Test/Css/BorderPropertyTests.cs
new file mode 100644
index 000000000..2442f1df7
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Css/BorderPropertyTests.cs
@@ -0,0 +1,512 @@
+using HtmlRenderer.Test.TestSupport;
+using TheArtOfDev.HtmlRenderer.Core.Parse;
+
+namespace HtmlRenderer.Test.Css;
+
+///
+/// Ported from PeachPDF.Tests/CSS/PropertyTests/BorderProperty.cs.
+/// The CSS engine port replaced the old hand-rolled border parsing entirely - both the
+/// Dictionary<string,string> longhand expansion via CssParser.AddProperty /
+/// SplitMultiDirectionValues (no legality validation of individual tokens: illegal keywords like
+/// "wavy" used to be stored verbatim, and a too-long value list used to silently leave the whole
+/// longhand set unset) and the public CssParser.ParseBorder whitespace-only tokenizer (which
+/// couldn't recognize a color function containing internal spaces, e.g. "rgb(255, 100, 0)", or a bare
+/// unitless "0" width, or "currentColor") - with the same real, typed, validating value-converter
+/// pipeline PeachPDF's own CSS engine uses (see Source/HtmlRenderer/Core/CssEngine/StyleProperties/Border/).
+/// Exercised here through StyleDeclaration 's longhand properties (colors normalize to "rgb(r, g, b)"/"rgba(r, g, b, a)"
+/// text; a longhand a shorthand's grammar didn't cover resolves to the literal string "initial" per CSS
+/// Cascading - a shorthand always sets every longhand it manages, explicitly or to its initial value -
+/// rather than being left unset/null as the old parser's positional splitting did).
+/// Every case the old whitespace-tokenizer/no-validation model couldn't handle now genuinely works
+/// against the real engine and is un-ignored below: BorderSpacingPercentIllegal, BorderStyleWavyIllegal,
+/// BorderLeftZeroLegal (bare "0" width), BorderBottomRgbLegal (color function with internal spaces), and
+/// BorderOutSetCurrentColor ("currentColor" keyword) - all verified by actually running against the real
+/// pipeline (see the probe values in this port's chat history), not assumed.
+///
+[TestClass]
+public sealed class BorderPropertyTests
+{
+ private static string GetProperty(string declaration, string propertyName)
+ {
+ var rule = new CssParser(new MockAdapter()).ParseInlineStyle(declaration);
+ Assert.IsNotNull(rule);
+ return rule.Style[propertyName];
+ }
+
+ private static string GetPriority(string declaration, string propertyName)
+ {
+ var rule = new CssParser(new MockAdapter()).ParseInlineStyle(declaration);
+ Assert.IsNotNull(rule);
+ return rule.Style.GetPropertyPriority(propertyName);
+ }
+
+ // ── border-spacing ───────────────────────────────────────────────────────────────────────────────────
+
+ [TestMethod]
+ public void BorderSpacingLengthLegal()
+ {
+ Assert.AreEqual("20px", GetProperty("border-spacing: 20px", "border-spacing"));
+ }
+
+ [TestMethod]
+ public void BorderSpacingZeroLegal()
+ {
+ Assert.AreEqual("0", GetProperty("border-spacing: 0", "border-spacing"));
+ }
+
+ [TestMethod]
+ public void BorderSpacingLengthLengthLegal()
+ {
+ Assert.AreEqual("15px 3em", GetProperty("border-spacing: 15px 3em", "border-spacing"));
+ }
+
+ [TestMethod]
+ public void BorderSpacingLengthZeroLegal()
+ {
+ Assert.AreEqual("15px 0", GetProperty("border-spacing: 15px 0", "border-spacing"));
+ }
+
+ [TestMethod]
+ public void BorderSpacingPercentIllegal()
+ {
+ // A percentage is not a legal border-spacing value (only is allowed) - the real engine
+ // now actually validates this (the old parser stored it verbatim, unfiltered).
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty("border-spacing: 15%", "border-spacing")));
+ }
+
+ // ── longhand border-*-color ──────────────────────────────────────────────────────────────────────────
+
+ [TestMethod]
+ public void BorderBottomColorRedLegal()
+ {
+ Assert.AreEqual("rgb(255, 0, 0)", GetProperty("border-bottom-color: red", "border-bottom-color"));
+ }
+
+ [TestMethod]
+ public void BorderTopColorHexLegal()
+ {
+ Assert.AreEqual("rgb(0, 255, 0)", GetProperty("border-top-color: #0F0", "border-top-color"));
+ }
+
+ [TestMethod]
+ public void BorderRightColorRgbaLegal()
+ {
+ Assert.AreEqual("rgba(1, 1, 1, 0)", GetProperty("border-right-color: rgba(1, 1, 1, 0)", "border-right-color"));
+ }
+
+ [TestMethod]
+ public void BorderLeftColorRgbLegal()
+ {
+ const string declaration = "border-left-color: rgb(1, 255, 100) !important";
+ Assert.AreEqual("rgb(1, 255, 100)", GetProperty(declaration, "border-left-color"));
+ Assert.AreEqual("important", GetPriority(declaration, "border-left-color"));
+ }
+
+ // ── border-color (all-sides shorthand) ───────────────────────────────────────────────────────────────
+
+ [TestMethod]
+ public void BorderColorTransparentLegal()
+ {
+ const string declaration = "border-color: transparent";
+
+ Assert.AreEqual("rgba(0, 0, 0, 0)", GetProperty(declaration, "border-top-color"));
+ Assert.AreEqual("rgba(0, 0, 0, 0)", GetProperty(declaration, "border-right-color"));
+ Assert.AreEqual("rgba(0, 0, 0, 0)", GetProperty(declaration, "border-bottom-color"));
+ Assert.AreEqual("rgba(0, 0, 0, 0)", GetProperty(declaration, "border-left-color"));
+ }
+
+ [TestMethod]
+ public void BorderColorRedGreenLegal()
+ {
+ const string declaration = "border-color: red green";
+
+ Assert.AreEqual("rgb(255, 0, 0)", GetProperty(declaration, "border-top-color"));
+ Assert.AreEqual("rgb(255, 0, 0)", GetProperty(declaration, "border-bottom-color"));
+ Assert.AreEqual("rgb(0, 128, 0)", GetProperty(declaration, "border-left-color"));
+ Assert.AreEqual("rgb(0, 128, 0)", GetProperty(declaration, "border-right-color"));
+ }
+
+ [TestMethod]
+ public void BorderColorRedRgbLegal()
+ {
+ const string declaration = "border-color: red rgb(0,0,0)";
+
+ Assert.AreEqual("rgb(255, 0, 0)", GetProperty(declaration, "border-top-color"));
+ Assert.AreEqual("rgb(255, 0, 0)", GetProperty(declaration, "border-bottom-color"));
+ Assert.AreEqual("rgb(0, 0, 0)", GetProperty(declaration, "border-left-color"));
+ Assert.AreEqual("rgb(0, 0, 0)", GetProperty(declaration, "border-right-color"));
+ }
+
+ [TestMethod]
+ public void BorderColorRedBlueGreenLegal()
+ {
+ const string declaration = "border-color: red blue green";
+
+ Assert.AreEqual("rgb(255, 0, 0)", GetProperty(declaration, "border-top-color"));
+ Assert.AreEqual("rgb(0, 0, 255)", GetProperty(declaration, "border-left-color"));
+ Assert.AreEqual("rgb(0, 0, 255)", GetProperty(declaration, "border-right-color"));
+ Assert.AreEqual("rgb(0, 128, 0)", GetProperty(declaration, "border-bottom-color"));
+ }
+
+ [TestMethod]
+ public void BorderColorRedBlueGreenBlackLegal()
+ {
+ const string declaration = "border-color: red blue green BLACK";
+
+ Assert.AreEqual("rgb(255, 0, 0)", GetProperty(declaration, "border-top-color"));
+ Assert.AreEqual("rgb(0, 0, 255)", GetProperty(declaration, "border-right-color"));
+ Assert.AreEqual("rgb(0, 128, 0)", GetProperty(declaration, "border-bottom-color"));
+ Assert.AreEqual("rgb(0, 0, 0)", GetProperty(declaration, "border-left-color"));
+ }
+
+ [TestMethod]
+ public void BorderColorRedBlueGreenBlackTransparentIllegal()
+ {
+ // A 5-value list is invalid for a 1/2/3/4-value periodic shorthand, so none of the
+ // border-*-color longhands get set at all.
+ const string declaration = "border-color: red blue green black transparent";
+
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty(declaration, "border-top-color")));
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty(declaration, "border-right-color")));
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty(declaration, "border-bottom-color")));
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty(declaration, "border-left-color")));
+ }
+
+ // ── border-style (longhand + all-sides shorthand) ────────────────────────────────────────────────────
+
+ [TestMethod]
+ public void BorderStyleDottedLegal()
+ {
+ const string declaration = "border-style: dotted";
+
+ Assert.AreEqual("dotted", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("dotted", GetProperty(declaration, "border-right-style"));
+ Assert.AreEqual("dotted", GetProperty(declaration, "border-bottom-style"));
+ Assert.AreEqual("dotted", GetProperty(declaration, "border-left-style"));
+ }
+
+ [TestMethod]
+ public void BorderStyleInsetOutsetUpperLegal()
+ {
+ const string declaration = "border-style: INSET OUTset";
+
+ Assert.AreEqual("inset", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("inset", GetProperty(declaration, "border-bottom-style"));
+ Assert.AreEqual("outset", GetProperty(declaration, "border-left-style"));
+ Assert.AreEqual("outset", GetProperty(declaration, "border-right-style"));
+ }
+
+ [TestMethod]
+ public void BorderStyleDoubleGrooveLegal()
+ {
+ const string declaration = "border-style: double groove";
+
+ Assert.AreEqual("double", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("double", GetProperty(declaration, "border-bottom-style"));
+ Assert.AreEqual("groove", GetProperty(declaration, "border-left-style"));
+ Assert.AreEqual("groove", GetProperty(declaration, "border-right-style"));
+ }
+
+ [TestMethod]
+ public void BorderStyleRidgeSolidDashedLegal()
+ {
+ const string declaration = "border-style: ridge solid dashed";
+
+ Assert.AreEqual("ridge", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("solid", GetProperty(declaration, "border-left-style"));
+ Assert.AreEqual("solid", GetProperty(declaration, "border-right-style"));
+ Assert.AreEqual("dashed", GetProperty(declaration, "border-bottom-style"));
+ }
+
+ [TestMethod]
+ public void BorderStyleHiddenDottedNoneNoneLegal()
+ {
+ const string declaration = "border-style : hidden dotted NONE nONe";
+
+ Assert.AreEqual("hidden", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("dotted", GetProperty(declaration, "border-right-style"));
+ Assert.AreEqual("none", GetProperty(declaration, "border-bottom-style"));
+ Assert.AreEqual("none", GetProperty(declaration, "border-left-style"));
+ }
+
+ [TestMethod]
+ public void BorderStyleWavyIllegal()
+ {
+ // An invalid border-style keyword is rejected by the real engine, so none of the
+ // border-*-style longhands get set (the old parser had no keyword validation at all and let
+ // "wavy" through unfiltered onto all four sides).
+ const string declaration = "border-style: wavy";
+
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty(declaration, "border-top-style")));
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty(declaration, "border-right-style")));
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty(declaration, "border-bottom-style")));
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty(declaration, "border-left-style")));
+ }
+
+ [TestMethod]
+ public void BorderBottomStyleGrooveLegal()
+ {
+ Assert.AreEqual("groove", GetProperty("border-bottom-style: GROOVE", "border-bottom-style"));
+ }
+
+ [TestMethod]
+ public void BorderTopStyleNoneLegal()
+ {
+ Assert.AreEqual("none", GetProperty("border-top-style:none", "border-top-style"));
+ }
+
+ [TestMethod]
+ public void BorderRightStyleDoubleLegal()
+ {
+ Assert.AreEqual("double", GetProperty("border-right-style:double", "border-right-style"));
+ }
+
+ [TestMethod]
+ public void BorderLeftStyleHiddenLegal()
+ {
+ const string declaration = "border-left-style: hidden !important";
+ Assert.AreEqual("hidden", GetProperty(declaration, "border-left-style"));
+ Assert.AreEqual("important", GetPriority(declaration, "border-left-style"));
+ }
+
+ // ── border-width (longhand + all-sides shorthand) ────────────────────────────────────────────────────
+ // NOTE: unlike the old parser (which stored the "thin"/"medium"/"thick" keyword text verbatim), the
+ // real engine's LineWidthConverter resolves these keywords straight to their pixel value at parse
+ // time (this fork's scale: thin=1px, medium=3px, thick=5px - matching PeachPDF's own scale, since
+ // both share the same vendored converter), so the stored longhand value is already "1px"/"3px"/"5px".
+
+ [TestMethod]
+ public void BorderBottomWidthThinLegal()
+ {
+ Assert.AreEqual("1px", GetProperty("border-bottom-width: THIN", "border-bottom-width"));
+ }
+
+ [TestMethod]
+ public void BorderTopWidthZeroLegal()
+ {
+ Assert.AreEqual("0", GetProperty("border-top-width: 0", "border-top-width"));
+ }
+
+ [TestMethod]
+ public void BorderRightWidthEmLegal()
+ {
+ Assert.AreEqual("3em", GetProperty("border-right-width: 3em", "border-right-width"));
+ }
+
+ [TestMethod]
+ public void BorderLeftWidthThickLegal()
+ {
+ const string declaration = "border-left-width: thick !important";
+ Assert.AreEqual("5px", GetProperty(declaration, "border-left-width"));
+ Assert.AreEqual("important", GetPriority(declaration, "border-left-width"));
+ }
+
+ [TestMethod]
+ public void BorderWidthMediumLegal()
+ {
+ const string declaration = "border-width: medium";
+
+ Assert.AreEqual("3px", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("3px", GetProperty(declaration, "border-right-width"));
+ Assert.AreEqual("3px", GetProperty(declaration, "border-bottom-width"));
+ Assert.AreEqual("3px", GetProperty(declaration, "border-left-width"));
+ }
+
+ [TestMethod]
+ public void BorderWidthLengthZeroLegal()
+ {
+ const string declaration = "border-width: 3px 0";
+
+ Assert.AreEqual("3px", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("3px", GetProperty(declaration, "border-bottom-width"));
+ Assert.AreEqual("0", GetProperty(declaration, "border-left-width"));
+ Assert.AreEqual("0", GetProperty(declaration, "border-right-width"));
+ }
+
+ [TestMethod]
+ public void BorderWidthThinLengthLegal()
+ {
+ const string declaration = "border-width: THIN 1px";
+
+ Assert.AreEqual("1px", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("1px", GetProperty(declaration, "border-bottom-width"));
+ Assert.AreEqual("1px", GetProperty(declaration, "border-left-width"));
+ Assert.AreEqual("1px", GetProperty(declaration, "border-right-width"));
+ }
+
+ [TestMethod]
+ public void BorderWidthMediumThinThickLegal()
+ {
+ const string declaration = "border-width: medium thin thick";
+
+ Assert.AreEqual("3px", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("1px", GetProperty(declaration, "border-left-width"));
+ Assert.AreEqual("1px", GetProperty(declaration, "border-right-width"));
+ Assert.AreEqual("5px", GetProperty(declaration, "border-bottom-width"));
+ }
+
+ [TestMethod]
+ public void BorderWidthLengthLengthLengthLengthLegal()
+ {
+ const string declaration = "border-width: 1px 2px 3px 4px !important ";
+
+ Assert.AreEqual("1px", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("2px", GetProperty(declaration, "border-right-width"));
+ Assert.AreEqual("3px", GetProperty(declaration, "border-bottom-width"));
+ Assert.AreEqual("4px", GetProperty(declaration, "border-left-width"));
+ }
+
+ [TestMethod]
+ public void BorderWidthLengthInEmZeroLegal()
+ {
+ const string declaration = "border-width: 0.3em 0 ";
+
+ Assert.AreEqual("0.3em", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("0.3em", GetProperty(declaration, "border-bottom-width"));
+ Assert.AreEqual("0", GetProperty(declaration, "border-left-width"));
+ Assert.AreEqual("0", GetProperty(declaration, "border-right-width"));
+ }
+
+ [TestMethod]
+ public void BorderWidthMediumZeroLengthThickLegal()
+ {
+ const string declaration = "border-width: medium 0 1px thick ";
+
+ Assert.AreEqual("3px", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("0", GetProperty(declaration, "border-right-width"));
+ Assert.AreEqual("1px", GetProperty(declaration, "border-bottom-width"));
+ Assert.AreEqual("5px", GetProperty(declaration, "border-left-width"));
+ }
+
+ [TestMethod]
+ public void BorderWidthZerosIllegal()
+ {
+ // A 5-value list is invalid for a 1/2/3/4-value periodic shorthand, so none of the
+ // border-*-width longhands get set at all.
+ const string declaration = "border-width: 0 0 0 0 0";
+
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty(declaration, "border-top-width")));
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty(declaration, "border-right-width")));
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty(declaration, "border-bottom-width")));
+ Assert.IsTrue(string.IsNullOrEmpty(GetProperty(declaration, "border-left-width")));
+ }
+
+ // ── border (single-side shorthand: "border", and equally "border-left/top/right/bottom", which share
+ // the exact same value grammar) - a longhand this shorthand's value didn't cover resolves to the
+ // literal string "initial" per CSS Cascading (a shorthand always sets every longhand it manages,
+ // explicitly or to its initial value), rather than being left unset the way the old positional
+ // whitespace-tokenizer parser left it. ───────────────────────────────────────────────────────────
+
+ [TestMethod]
+ public void BorderZeroLegal()
+ {
+ // A bare "0" is a legal border width. The old ParseBorderWidth only recognized a bare number as
+ // a width when at least 3 characters long (a number plus a 2-character unit) or one of the
+ // thin/medium/thick keywords, so a bare unitless "0" wasn't recognized at all - restored here
+ // now that the real engine's LineWidthConverter handles it correctly.
+ const string declaration = "border: 0";
+
+ Assert.AreEqual("0", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("initial", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("initial", GetProperty(declaration, "border-top-color"));
+ }
+
+ [TestMethod]
+ public void BorderLineStyleLegal()
+ {
+ const string declaration = "border: dotted";
+
+ Assert.AreEqual("initial", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("dotted", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("initial", GetProperty(declaration, "border-top-color"));
+ }
+
+ [TestMethod]
+ public void BorderLengthRedLegal()
+ {
+ const string declaration = "border : 2px red ";
+
+ Assert.AreEqual("2px", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("initial", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("rgb(255, 0, 0)", GetProperty(declaration, "border-top-color"));
+ }
+
+ [TestMethod]
+ public void BorderRgbLegal()
+ {
+ // "rgb(255, 100, 0)" is recognized as the border color. The old ParseBorder's whitespace-only
+ // tokenizer (CommonUtils.GetNextSubString has no notion of parentheses) split a color function
+ // containing internal spaces into unrecognizable fragments ("rgb(255,", "100,", "0)") that none
+ // individually resolved to a width/style/color - restored here now that the real engine's
+ // tokenizer correctly treats the whole function() as one token.
+ const string declaration = "border : rgb(255, 100, 0) ";
+
+ Assert.AreEqual("initial", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("initial", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("rgb(255, 100, 0)", GetProperty(declaration, "border-top-color"));
+ }
+
+ [TestMethod]
+ public void BorderGrooveRgbLegal()
+ {
+ const string declaration = "border : GROOVE rgb(255, 100, 0) ";
+
+ Assert.AreEqual("initial", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("groove", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("rgb(255, 100, 0)", GetProperty(declaration, "border-top-color"));
+ }
+
+ [TestMethod]
+ public void BorderInsetGreenLengthLegal()
+ {
+ const string declaration = "border : inset green 3em ";
+
+ Assert.AreEqual("3em", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("inset", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("rgb(0, 128, 0)", GetProperty(declaration, "border-top-color"));
+ }
+
+ [TestMethod]
+ public void BorderRedSolidLengthLegal()
+ {
+ const string declaration = "border : red SOLID 1px ";
+
+ Assert.AreEqual("1px", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("solid", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("rgb(255, 0, 0)", GetProperty(declaration, "border-top-color"));
+ }
+
+ [TestMethod]
+ public void BorderLengthBlackDoubleLegal()
+ {
+ const string declaration = "border : 0.5px black double ";
+
+ Assert.AreEqual("0.5px", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("double", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("rgb(0, 0, 0)", GetProperty(declaration, "border-top-color"));
+ }
+
+ [TestMethod]
+ public void BorderOutSetCurrentColor()
+ {
+ // "currentColor" is now a legal color keyword, recognized as the border color - the old parser
+ // had no special handling for it (looked it up like any other named color, which the adapter
+ // doesn't know, so it was rejected).
+ const string declaration = "border: 1px outset currentColor";
+
+ Assert.AreEqual("1px", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("outset", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("currentColor", GetProperty(declaration, "border-top-color"));
+ }
+
+ [TestMethod]
+ public void BorderOutSetWithNoColor()
+ {
+ const string declaration = "border: 1px outset";
+
+ Assert.AreEqual("1px", GetProperty(declaration, "border-top-width"));
+ Assert.AreEqual("outset", GetProperty(declaration, "border-top-style"));
+ Assert.AreEqual("initial", GetProperty(declaration, "border-top-color"));
+ }
+}
diff --git a/Source/Test/HtmlRenderer.Test/Css/BorderRadiusPropertyTests.cs b/Source/Test/HtmlRenderer.Test/Css/BorderRadiusPropertyTests.cs
new file mode 100644
index 000000000..e89912a86
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Css/BorderRadiusPropertyTests.cs
@@ -0,0 +1,309 @@
+using HtmlRenderer.Test.CssEngineSupport;
+using TheArtOfDev.HtmlRenderer.Core.CssEngine;
+
+namespace HtmlRenderer.Test.Css;
+
+/// Ported from PeachPDF.Tests/CSS/PropertyTests/BorderRadiusProperty.cs. Pure CSSOM parse tests,
+/// including CSS-text round-trip/simplification tests via
+[TestClass]
+public sealed class BorderRadiusPropertyTests
+{
+ [TestMethod]
+ public void BorderBottomLeftRadiusPxPxLegal()
+ {
+ var snippet = "border-bottom-left-radius: 40px 40px";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-bottom-left-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderBottomLeftRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("40px 40px", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderBottomLeftRadiusPxEmLegal()
+ {
+ var snippet = "border-bottom-left-radius : 40px 20em";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-bottom-left-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderBottomLeftRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("40px 20em", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderBottomLeftRadiusPxPercentLegal()
+ {
+ var snippet = "border-bottom-left-radius: 10px 5%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-bottom-left-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderBottomLeftRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10px 5%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderBottomLeftRadiusPercentLegal()
+ {
+ var snippet = "border-bottom-left-radius: 10%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-bottom-left-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderBottomLeftRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("10%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderBottomRightRadiusZeroLegal()
+ {
+ var snippet = "border-bottom-right-radius: 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-bottom-right-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderBottomRightRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("0", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderBottomRightRadiusPxLegal()
+ {
+ var snippet = "border-bottom-right-radius: 20px";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-bottom-right-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderBottomRightRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("20px", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderTopLeftRadiusCmLegal()
+ {
+ var snippet = "border-top-left-radius: 3.5cm";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-top-left-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderTopLeftRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("3.5cm", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderTopRightRadiusPercentPercentLegal()
+ {
+ var snippet = "border-top-right-radius: 15% 3.5%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-top-right-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderTopRightRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("15% 3.5%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderRadiusPercentPercentLegal()
+ {
+ var snippet = "border-radius: 15% 3.5%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("15% 3.5%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderRadiusZeroLegal()
+ {
+ var snippet = "border-radius: 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("0", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderRadiusThreeLengthsLegal()
+ {
+ var snippet = "border-radius: 2px 4px 3px";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("2px 4px 3px", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderRadiusFourLengthsLegal()
+ {
+ var snippet = "border-radius: 2px 4px 3px 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("2px 4px 3px 0", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderRadiusFiveLengthsIllegal()
+ {
+ var snippet = "border-radius: 2px 4px 3px 0 1px";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BorderRadiusLengthFractionLegal()
+ {
+ var snippet = "border-radius: 1em/5em";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("1em / 5em", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderRadiusLengthFractionInbalancedLegal()
+ {
+ var snippet = "border-radius: 4px 3px 6px / 2px 4px";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("4px 3px 6px / 2px 4px", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderRadiusFullFractionLegal()
+ {
+ var snippet = "border-radius: 4px 3px 6px 1em / 2px 4px 0 20%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("4px 3px 6px 1em / 2px 4px 0 20%", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BorderRadiusFiveTailFractionIllegal()
+ {
+ var snippet = "border-radius: 4px 3px 6px 1em / 2px 4px 0 20% 0";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BorderRadiusFiveHeadFractionIllegal()
+ {
+ var snippet = "border-radius: 4px 3px 6px 1em 0 / 2px 4px 0 20%";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("border-radius", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BorderRadiusProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsFalse(concrete.HasValue);
+ }
+
+ [TestMethod]
+ public void BorderRadiusCircleShouldBeExpandedAndRecombinedCorrectly()
+ {
+ var snippet = ".centered { border-radius: 5px; }";
+ var expected = ".centered { border-radius: 5px }";
+ var result = CssConstructionFunctions.ParseRule(snippet);
+ var actual = result.Text;
+ Assert.AreEqual(expected, actual);
+ }
+
+ [TestMethod]
+ public void BorderRadiusEllipseShouldBeExpandedAndRecombinedCorrectly()
+ {
+ var snippet = ".centered { border-radius: 5px/3px; }";
+ var expected = ".centered { border-radius: 5px / 3px }";
+ var result = CssConstructionFunctions.ParseRule(snippet);
+ var actual = result.Text;
+ Assert.AreEqual(expected, actual);
+ }
+
+ [TestMethod]
+ public void BorderRadiusSimplificationShouldWork()
+ {
+ var snippet = ".centered { border-top-left-radius: 0 1px; border-bottom-left-radius: 1px 2px; border-top-right-radius: 0 3px; border-bottom-right-radius: 1px 4px; }";
+ var expected = ".centered { border-radius: 0 0 1px 1px / 1px 3px 4px 2px }";
+ var result = CssConstructionFunctions.ParseRule(snippet);
+ var actual = result.Text;
+ Assert.AreEqual(expected, actual);
+ }
+
+ [TestMethod]
+ public void BorderRadiusRecombinationAndReductionCheck()
+ {
+ var snippet = ".centered { border-top-left-radius: 0 1px; border-bottom-left-radius: 0 1px; border-top-right-radius: 1px 1px; border-bottom-right-radius: 0 1px; }";
+ var expected = ".centered { border-radius: 0 1px 0 0 / 1px }";
+ var result = CssConstructionFunctions.ParseRule(snippet);
+ var actual = result.Text;
+ Assert.AreEqual(expected, actual);
+ }
+
+ [TestMethod]
+ public void BorderRadiusPureCircleRecombination()
+ {
+ var snippet = ".test { border-top-left-radius:15px;border-bottom-left-radius:15px;border-bottom-right-radius:0;border-top-right-radius:0;}";
+ var expected = ".test { border-radius: 15px 0 0 15px }";
+ var result = CssConstructionFunctions.ParseRule(snippet);
+ var actual = result.Text;
+ Assert.AreEqual(expected, actual);
+ }
+}
diff --git a/Source/Test/HtmlRenderer.Test/Css/BoxShadowGrammarTests.cs b/Source/Test/HtmlRenderer.Test/Css/BoxShadowGrammarTests.cs
new file mode 100644
index 000000000..5c3778315
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Css/BoxShadowGrammarTests.cs
@@ -0,0 +1,167 @@
+using System.Collections.Generic;
+using System.Linq;
+using HtmlRenderer.Test.CssEngineSupport;
+using TheArtOfDev.HtmlRenderer.Core.CssEngine;
+using TheArtOfDev.HtmlRenderer.Core.Parse;
+
+namespace HtmlRenderer.Test.Css;
+
+///
+/// Ported from PeachPDF.Tests/CSS/BoxShadowGrammarTests.cs.
+/// Tests for the shared box-shadow value grammar
+/// none | [ inset? && <length>{2,4} && <color>? ]# ) and its
+/// Layer-A accept/reject via the full parser.
+///
+[TestClass]
+public sealed class BoxShadowGrammarTests
+{
+ private static List Parse(string value) =>
+ BoxShadowGrammar.TryParse(CssValueParser.GetCssTokens(value));
+
+ [TestMethod]
+ public void None_ReturnsEmptyList()
+ {
+ var layers = Parse("none");
+ Assert.IsNotNull(layers);
+ Assert.AreEqual(0, layers.Count);
+ }
+
+ [TestMethod]
+ public void TwoLengths_OffsetsOnly()
+ {
+ var layers = Parse("2px 3px");
+ Assert.AreEqual(1, layers.Count);
+ var layer = layers[0];
+ Assert.IsFalse(layer.Inset);
+ Assert.AreEqual("2px", layer.OffsetX);
+ Assert.AreEqual("3px", layer.OffsetY);
+ Assert.AreEqual("0", layer.Blur);
+ Assert.AreEqual("0", layer.Spread);
+ Assert.IsNull(layer.Color);
+ }
+
+ [TestMethod]
+ public void ThreeLengths_HasBlur()
+ {
+ var layers = Parse("2px 2px 5px");
+ Assert.AreEqual(1, layers.Count);
+ var layer = layers[0];
+ Assert.AreEqual("5px", layer.Blur);
+ Assert.AreEqual("0", layer.Spread);
+ }
+
+ [TestMethod]
+ public void FourLengths_HasBlurAndSpread()
+ {
+ var layers = Parse("1px 1px 2px 3px");
+ Assert.AreEqual(1, layers.Count);
+ var layer = layers[0];
+ Assert.AreEqual("2px", layer.Blur);
+ Assert.AreEqual("3px", layer.Spread);
+ }
+
+ [TestMethod]
+ public void Inset_WithColor()
+ {
+ var layers = Parse("inset 0 0 5px red");
+ Assert.AreEqual(1, layers.Count);
+ var layer = layers[0];
+ Assert.IsTrue(layer.Inset);
+ Assert.AreEqual("0", layer.OffsetX);
+ Assert.AreEqual("0", layer.OffsetY);
+ Assert.AreEqual("5px", layer.Blur);
+ Assert.AreEqual("red", layer.Color);
+ }
+
+ [TestMethod]
+ [DataRow("2px 2px red", "red")]
+ [DataRow("2px 2px #fff", "#fff")] // letter-leading hex (Hash token)
+ [DataRow("2px 2px #08f", "#08f")] // digit-leading short hex (Delim + dimension)
+ [DataRow("2px 2px #000", "#000")] // digit-leading hex, all digits (Delim + number)
+ [DataRow("2px 2px #0088ff", "#0088ff")] // digit-leading long hex
+ [DataRow("2px 2px rgba(0,0,0,.5)", "rgba(0,0,0,.5)")]
+ [DataRow("2px 2px currentColor", "currentColor")]
+ public void Color_IsCaptured(string value, string expectedColor)
+ {
+ var layers = Parse(value);
+ Assert.AreEqual(1, layers.Count);
+ Assert.AreEqual(expectedColor, layers[0].Color);
+ }
+
+ [TestMethod]
+ public void ColorBeforeLengths_IsAccepted()
+ {
+ // The && grammar allows the color in any position, including before the lengths.
+ var layers = Parse("red 2px 2px");
+ Assert.AreEqual(1, layers.Count);
+ var layer = layers[0];
+ Assert.AreEqual("red", layer.Color);
+ Assert.AreEqual("2px", layer.OffsetX);
+ }
+
+ [TestMethod]
+ public void EmValidLengthsAreKeptAsAuthoredStrings()
+ {
+ var layers = Parse("0.5em 0.5em 1em");
+ Assert.AreEqual(1, layers.Count);
+ var layer = layers[0];
+ Assert.AreEqual("0.5em", layer.OffsetX);
+ Assert.AreEqual("1em", layer.Blur);
+ }
+
+ [TestMethod]
+ public void NegativeOffsetsAndSpread_AreValid()
+ {
+ var layers = Parse("-2px -3px 4px -1px");
+ Assert.AreEqual(1, layers.Count);
+ var layer = layers[0];
+ Assert.AreEqual("-2px", layer.OffsetX);
+ Assert.AreEqual("-3px", layer.OffsetY);
+ Assert.AreEqual("-1px", layer.Spread);
+ }
+
+ [TestMethod]
+ public void MultipleLayers_ParseInOrder()
+ {
+ var layers = Parse("1px 1px 2px 3px rgba(0,0,0,.5), inset 0 0 0 1px blue");
+ Assert.AreEqual(2, layers.Count);
+ Assert.IsFalse(layers[0].Inset);
+ Assert.AreEqual("rgba(0,0,0,.5)", layers[0].Color);
+ Assert.IsTrue(layers[1].Inset);
+ Assert.AreEqual("blue", layers[1].Color);
+ }
+
+ [TestMethod]
+ [DataRow("")]
+ [DataRow("banana")] // no lengths
+ [DataRow("2px")] // only one length
+ [DataRow("2px 2px 2px 2px 2px")] // five lengths
+ [DataRow("inset inset 2px 2px")] // inset twice
+ [DataRow("2px 2px -5px red")] // negative blur radius
+ [DataRow("2px red 2px")] // non-contiguous lengths
+ [DataRow("2px 2px banana")] // invalid color keyword
+ [DataRow("2px 2px #12")] // "#" + a 2-digit number: not a valid hex length
+ [DataRow("2px 2px #")] // a bare "#" delimiter with nothing after it
+ [DataRow("2px 50%")] // percentage is not a valid length
+ [DataRow("2px 2px 50%")] // percentage where a color/length is expected
+ [DataRow("2px 2px red blue")] // two colors
+ public void Invalid_ReturnsNull(string value)
+ {
+ Assert.IsNull(Parse(value));
+ }
+
+ [TestMethod]
+ [DataRow("box-shadow: none", true)]
+ [DataRow("box-shadow: 2px 2px", true)]
+ [DataRow("box-shadow: inset 0 0 5px red", true)]
+ [DataRow("box-shadow: 1px 1px 2px 3px rgba(0,0,0,.5), 0 0 0 1px blue", true)]
+ [DataRow("box-shadow: banana", false)]
+ [DataRow("box-shadow: 2px 50%", false)]
+ public void LayerA_AcceptsValid_RejectsInvalid(string declaration, bool shouldApply)
+ {
+ var sheet = CssConstructionFunctions.ParseStyleSheet($"div {{ {declaration}; }}");
+ var style = sheet.Rules.OfType().Single().Style;
+ var applied = !string.IsNullOrEmpty(style.GetPropertyValue("box-shadow"));
+ Assert.AreEqual(shouldApply, applied);
+ }
+}
diff --git a/Source/Test/HtmlRenderer.Test/Css/BoxSizingPropertyTests.cs b/Source/Test/HtmlRenderer.Test/Css/BoxSizingPropertyTests.cs
new file mode 100644
index 000000000..e61df7f57
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Css/BoxSizingPropertyTests.cs
@@ -0,0 +1,37 @@
+using HtmlRenderer.Test.CssEngineSupport;
+using TheArtOfDev.HtmlRenderer.Core.CssEngine;
+
+namespace HtmlRenderer.Test.Css;
+
+/// Ported from PeachPDF.Tests/CSS/PropertyTests/BoxSizingPropertyTests.cs. Pure CSSOM parse tests.
+[TestClass]
+public sealed class BoxSizingPropertyTests
+{
+ [TestMethod]
+ public void BoxSizingContentBoxLegal()
+ {
+ var snippet = "box-sizing: content-box";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("box-sizing", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BoxSizingProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("content-box", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BoxSizingBorderBoxLegal()
+ {
+ var snippet = "box-sizing: border-box";
+ var property = CssConstructionFunctions.ParseDeclaration(snippet);
+ Assert.AreEqual("box-sizing", property.Name);
+ Assert.IsFalse(property.IsImportant);
+ Assert.IsInstanceOfType(property);
+ var concrete = (BoxSizingProperty)property;
+ Assert.IsFalse(concrete.IsInherited);
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("border-box", concrete.Value);
+ }
+}
diff --git a/Source/Test/HtmlRenderer.Test/Css/CalcEvaluatorTests.cs b/Source/Test/HtmlRenderer.Test/Css/CalcEvaluatorTests.cs
new file mode 100644
index 000000000..6d3f8b34c
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Css/CalcEvaluatorTests.cs
@@ -0,0 +1,98 @@
+using System;
+using System.Linq;
+using TheArtOfDev.HtmlRenderer.Core.CssEngine;
+using TheArtOfDev.HtmlRenderer.Core.Parse;
+
+namespace HtmlRenderer.Test.Css;
+
+///
+/// Ported from PeachPDF.Tests/CSS/CalcEvaluatorTests.cs.
+/// Tests for calc(1turn * 0.35) ) evaluates to radians (the canonical angle unit).
+/// This is what lets a conic-gradient stop position be authored as a calc() expression - the
+/// Charts.css pie-slice case, whose every stop is calc(1turn * <value>) .
+///
+/// HTML-Renderer's false below (and returnPoints keeps its default of false ) to match PeachPDF's
+/// 3-arg semantics.
+///
+[TestClass]
+public sealed class CalcEvaluatorTests
+{
+ private static double? EvaluateAngle(string calc)
+ {
+ var function = CssValueParser.GetCssTokens(calc).OfType().Single();
+ var node = CalcParser.Parse(function);
+ Assert.IsNotNull(node);
+ // A full turn is 2π radians; em/rem factors are irrelevant to an angle calc.
+ return CalcEvaluator.Evaluate(node!, new CalcContext(2.0 * Math.PI, 0, 0, false));
+ }
+
+ [TestMethod]
+ [DataRow("calc(1turn * 0.35)", 0.35)]
+ [DataRow("calc(1turn * 0.5)", 0.5)]
+ [DataRow("calc(0.25turn)", 0.25)]
+ public void AngleCalc_TurnScaled_EvaluatesToRadians(string calc, double expectedTurns)
+ {
+ var radians = EvaluateAngle(calc);
+ Assert.IsNotNull(radians);
+ Assert.AreEqual(expectedTurns * 2.0 * Math.PI, radians!.Value, 1e-4);
+ }
+
+ [TestMethod]
+ public void AngleCalc_Degrees_EvaluatesToRadians()
+ {
+ var radians = EvaluateAngle("calc(90deg + 90deg)");
+ Assert.IsNotNull(radians);
+ Assert.AreEqual(Math.PI, radians!.Value, 1e-4); // 180deg
+ }
+
+ // ── / calc leaves (issue #229 gap 2) ───────────────────────
+ // These node types are produced by CalcParser for @property ``/`` validation.
+ // No layout property evaluates or serializes a time/resolution calc, so these tests exercise the
+ // CalcEvaluator/CalcSerializer/CalcNode leaf handling that path never reaches directly.
+
+ private static double? Evaluate(string calc)
+ {
+ var function = CssValueParser.GetCssTokens(calc).OfType().Single();
+ var node = CalcParser.Parse(function);
+ Assert.IsNotNull(node);
+ return CalcEvaluator.Evaluate(node!, new CalcContext(0, 0, 0, false));
+ }
+
+ [TestMethod]
+ [DataRow("calc(1s + 2s)", 3000.0)] // canonical unit is milliseconds
+ [DataRow("calc(500ms)", 500.0)]
+ [DataRow("calc(2s * 3)", 6000.0)]
+ public void TimeCalc_EvaluatesToMilliseconds(string calc, double expectedMs)
+ {
+ Assert.AreEqual(expectedMs, Evaluate(calc)!.Value, 1e-3);
+ }
+
+ [TestMethod]
+ [DataRow("calc(2dppx * 2)", 4.0)] // canonical unit is dots-per-pixel
+ [DataRow("calc(96dpi)", 1.0)] // 96dpi == 1dppx
+ public void ResolutionCalc_EvaluatesToDotsPerPixel(string calc, double expectedDppx)
+ {
+ Assert.AreEqual(expectedDppx, Evaluate(calc)!.Value, 1e-3);
+ }
+
+ private static string Serialize(string calc, CalcCategory category)
+ {
+ var function = CssValueParser.GetCssTokens(calc).OfType().Single();
+ var node = CalcParser.Parse(function);
+ Assert.IsNotNull(node);
+ return CalcSerializer.Serialize(node!, category);
+ }
+
+ [TestMethod]
+ [DataRow("calc(1s + 2s)", "time", "calc(1s + 2s)")]
+ [DataRow("calc(2dppx * 2)", "resolution", "calc(2dppx * 2)")]
+ public void TimeResolutionCalc_SerializesToNormalizedText(string calc, string kind, string expected)
+ {
+ var category = kind == "time" ? CalcCategory.Time : CalcCategory.Resolution;
+ Assert.AreEqual(expected, Serialize(calc, category));
+ }
+}
diff --git a/Source/Test/HtmlRenderer.Test/Css/CalcPropertyTests.cs b/Source/Test/HtmlRenderer.Test/Css/CalcPropertyTests.cs
new file mode 100644
index 000000000..9ae3d1db1
--- /dev/null
+++ b/Source/Test/HtmlRenderer.Test/Css/CalcPropertyTests.cs
@@ -0,0 +1,435 @@
+using HtmlRenderer.Test.CssEngineSupport;
+using TheArtOfDev.HtmlRenderer.Core.CssEngine;
+
+namespace HtmlRenderer.Test.Css;
+
+///
+/// Ported from PeachPDF.Tests/CSS/PropertyTests/CalcPropertyTests.cs.
+/// CSS-object-model-level unit tests for calc()/min()/max()/clamp(): parsing, type-checking, and
+/// canonical text, exercised against HTML-Renderer's ported Source/HtmlRenderer/Core/CssEngine/Calc/
+/// folding engine. Pure CSSOM parse tests - no layout/cascade-level numeric resolution here.
+///
+[TestClass]
+public sealed class CalcPropertyTests
+{
+ // ── basic arithmetic (fully numeric/absolute -> folds to a plain value) ─────────────
+
+ [TestMethod]
+ public void Width_CalcAddition_FoldsToPixelLength()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(100px + 20px)");
+ Assert.AreEqual("width", property.Name);
+ Assert.IsInstanceOfType(property);
+ var concrete = (WidthProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("120px", concrete.Value);
+ }
+
+ [TestMethod]
+ public void Width_CalcSubtraction_FoldsToPixelLength()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(200px - 60px)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("140px", property.Value);
+ }
+
+ [TestMethod]
+ public void Width_CalcMultiplication_FoldsToPixelLength()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(20px * 4)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("80px", property.Value);
+ }
+
+ [TestMethod]
+ public void Width_CalcMultiplicationNumberFirst_FoldsToPixelLength()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(4 * 20px)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("80px", property.Value);
+ }
+
+ [TestMethod]
+ public void Width_CalcDivision_FoldsToPixelLength()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(100px / 4)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("25px", property.Value);
+ }
+
+ [TestMethod]
+ public void Width_CalcMixedAbsoluteUnits_FoldsToPixelLength()
+ {
+ // px is spec-correct (1px = 0.75pt, i.e. 96dpi): 1in = 96px, 2cm = 2*96/2.54 ~= 75.59px,
+ // folding to ~171.59px. (Internally that's 1in = 72pt + 2cm = 56.69pt = 128.69pt, serialized
+ // back to canonical px as 128.69 / 0.75.)
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(1in + 2cm)");
+ Assert.IsTrue(property.HasValue);
+ StringAssert.StartsWith(property.Value, "171.");
+ StringAssert.EndsWith(property.Value, "px");
+ }
+
+ // ── mixed relative units (can't fold until layout - canonical calc() text preserved) ─
+
+ [TestMethod]
+ public void Width_CalcMixedEmPx_PreservesCalcExpression()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(1em + 5px)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("calc(1em + 5px)", property.Value);
+ }
+
+ [TestMethod]
+ public void Width_CalcPercentMinusPx_PreservesCalcExpression()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(100% - 20px)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("calc(100% - 20px)", property.Value);
+ }
+
+ // ── nesting ───────────────────────────────────────────────────────────────────────
+
+ [TestMethod]
+ public void Width_NestedCalc_FoldsToPixelLength()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(calc(10px + 10px) * 2)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("40px", property.Value);
+ }
+
+ [TestMethod]
+ public void Width_ParenGrouping_FoldsToPixelLength()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc((10px + 10px) * 2)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("40px", property.Value);
+ }
+
+ [TestMethod]
+ public void Width_ParenGroupingMixedUnits_PreservesGroupingInCanonicalText()
+ {
+ // Without the parens this would mean "1em + (5px * 2)" = a different expression;
+ // the canonical text must keep the grouping to stay semantically equivalent.
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc((1em + 5px) * 2)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("calc((1em + 5px) * 2)", property.Value);
+ }
+
+ // ── min() / max() / clamp() ──────────────────────────────────────────────────────
+
+ [TestMethod]
+ public void Width_Min_FoldsToSmallerPixelLength()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: min(150px, 100px)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("100px", property.Value);
+ }
+
+ [TestMethod]
+ public void Width_Max_FoldsToLargerPixelLength()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: max(150px, 100px)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("150px", property.Value);
+ }
+
+ [TestMethod]
+ public void Width_MinMixedUnits_PreservesCanonicalText()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: min(10px, 1em)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("min(10px, 1em)", property.Value);
+ }
+
+ [TestMethod]
+ public void Width_ClampWithPercent_PreservesCanonicalText()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: clamp(10px, 50%, 200px)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("clamp(10px, 50%, 200px)", property.Value);
+ }
+
+ [TestMethod]
+ public void Width_ClampAllAbsolute_FoldsToPixelLength()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: clamp(10px, 300px, 150px)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("150px", property.Value);
+ }
+
+ [TestMethod]
+ public void Width_ClampWrongArgCount_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: clamp(10px, 20px)");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ [TestMethod]
+ public void Width_MinNoArgs_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: min()");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ // ── plain-number category (NumberConverter-based properties) ────────────────────
+
+ [TestMethod]
+ public void FlexGrow_CalcNumberArithmetic_FoldsToPlainNumber()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("flex-grow: calc(1 + 1)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("2", property.Value);
+ }
+
+ [TestMethod]
+ public void FlexGrow_CalcWithLength_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("flex-grow: calc(1px + 2px)");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ // ── invalid / degenerate expressions ─────────────────────────────────────────────
+
+ [TestMethod]
+ public void Width_CalcDivideByZero_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(10px / 0)");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ [TestMethod]
+ public void Width_CalcAddNumberToLength_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(10px + 5)");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ [TestMethod]
+ public void Width_CalcMultiplyTwoLengths_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(10px * 5px)");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ [TestMethod]
+ public void Width_CalcDivideByLength_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(10px / 5px)");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ [TestMethod]
+ public void Width_CalcNoWhitespaceAroundPlus_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(10px+5px)");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ [TestMethod]
+ public void Width_CalcWhitespaceOnOneSideOfMinus_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(10px -5px)");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ [TestMethod]
+ public void Width_CalcUnbalancedParens_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(10px + (5px)");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ [TestMethod]
+ public void Width_CalcAngleUnit_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(10deg + 5deg)");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ [TestMethod]
+ public void Width_CalcEmpty_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc()");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ // ── var() interaction ─────────────────────────────────────────────────────────────
+
+ [TestMethod]
+ public void Width_CalcWithVar_StoredOpaquely()
+ {
+ // var() bypasses the strict per-property converter entirely (Property.TrySetValue routes
+ // any var()-containing value to Converters.Any) - the raw text round-trips unresolved here;
+ // DomParser resolves and re-validates it through the real converter at cascade time.
+ var property = CssConstructionFunctions.ParseDeclaration("width: calc(var(--x) + 10px)");
+ Assert.IsTrue(property.HasValue);
+ StringAssert.Contains(property.Value, "var(");
+ StringAssert.Contains(property.Value, "calc(");
+ }
+
+ // ── transform function arguments ─────────────────────────────────────────────────
+
+ [TestMethod]
+ public void Transform_TranslateXCalc_Legal()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("transform: translateX(calc(10px + 5px))");
+ Assert.IsInstanceOfType(property);
+ var concrete = (TransformProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("translateX(15px)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void Transform_ScaleCalc_Legal()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("transform: scale(calc(1 + 1))");
+ Assert.IsInstanceOfType(property);
+ var concrete = (TransformProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("scale(2)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void Transform_ScaleCalcArithmeticOperators_FoldsToPlainNumber()
+ {
+ // Exercises CalcTypeChecker.FoldBinaryNumber's -, *, and / arms (+ is already covered by
+ // Transform_ScaleCalc_Legal above), plus FoldUnaryNumber's negation.
+ Assert.AreEqual("scale(1)", ((TransformProperty)CssConstructionFunctions.ParseDeclaration("transform: scale(calc(3 - 2))")).Value);
+ Assert.AreEqual("scale(6)", ((TransformProperty)CssConstructionFunctions.ParseDeclaration("transform: scale(calc(2 * 3))")).Value);
+ Assert.AreEqual("scale(3)", ((TransformProperty)CssConstructionFunctions.ParseDeclaration("transform: scale(calc(6 / 2))")).Value);
+ Assert.AreEqual("scale(-2)", ((TransformProperty)CssConstructionFunctions.ParseDeclaration("transform: scale(calc(-2))")).Value);
+ }
+
+ [TestMethod]
+ public void Transform_ScaleCalcMinMaxClamp_FoldsToPlainNumber()
+ {
+ // Exercises CalcTypeChecker.FoldCallNumber: min()/max()/clamp() nested inside a Number-
+ // category calc() expression, not just the plain-arithmetic case above.
+ Assert.AreEqual("scale(2)", ((TransformProperty)CssConstructionFunctions.ParseDeclaration("transform: scale(calc(min(2, 3)))")).Value);
+ Assert.AreEqual("scale(3)", ((TransformProperty)CssConstructionFunctions.ParseDeclaration("transform: scale(calc(max(2, 3)))")).Value);
+ Assert.AreEqual("scale(2)", ((TransformProperty)CssConstructionFunctions.ParseDeclaration("transform: scale(calc(clamp(1, 2, 3)))")).Value);
+ }
+
+ // ── angle calc() (rotate/skew, gradient direction, hsl hue) ──────────────────────
+
+ [TestMethod]
+ public void Transform_RotateCalcSameUnit_FoldsToDegrees()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("transform: rotate(calc(45deg + 10deg))");
+ Assert.IsInstanceOfType(property);
+ var concrete = (TransformProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("rotate(55deg)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void Transform_SkewXCalcMixedAngleUnits_FoldsToDegrees()
+ {
+ // 1turn / 4 = 90deg - division by a plain number is legal for an angle numerator.
+ var property = CssConstructionFunctions.ParseDeclaration("transform: skewX(calc(1turn / 4))");
+ Assert.IsInstanceOfType(property);
+ var concrete = (TransformProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("skewX(90deg)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void BackgroundImage_LinearGradientAngleCalc_FoldsToDegrees()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("background-image: linear-gradient(calc(45deg + 45deg), red, blue)");
+ Assert.IsTrue(property.HasValue);
+ StringAssert.StartsWith(property.Value, "linear-gradient(90deg,");
+ }
+
+ [TestMethod]
+ public void Transform_RotateCalcUnaryNegation_FoldsToDegrees()
+ {
+ // Exercises CalcSerializer.FoldUnaryAngle.
+ var property = CssConstructionFunctions.ParseDeclaration("transform: rotate(calc(-(45deg)))");
+ Assert.IsInstanceOfType(property);
+ var concrete = (TransformProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("rotate(-45deg)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void Transform_RotateCalcNumberTimesAngle_FoldsToDegrees()
+ {
+ // Exercises CalcSerializer.FoldMultiplicativeAngle's right-hand-is-angle branch (the sibling
+ // "angle * number" form goes through the left-hand branch, already covered by the plain
+ // arithmetic scale/rotate tests above).
+ var property = CssConstructionFunctions.ParseDeclaration("transform: rotate(calc(2 * 45deg))");
+ Assert.IsInstanceOfType(property);
+ var concrete = (TransformProperty)property;
+ Assert.IsTrue(concrete.HasValue);
+ Assert.AreEqual("rotate(90deg)", concrete.Value);
+ }
+
+ [TestMethod]
+ public void Transform_RotateCalcMinMaxClamp_FoldsToDegrees()
+ {
+ // Exercises CalcSerializer.FoldCallAngle: min()/max()/clamp() nested inside an Angle-
+ // category calc() expression, not just the plain-arithmetic case above.
+ Assert.AreEqual("rotate(45deg)", ((TransformProperty)CssConstructionFunctions.ParseDeclaration("transform: rotate(calc(min(45deg, 90deg)))")).Value);
+ Assert.AreEqual("rotate(90deg)", ((TransformProperty)CssConstructionFunctions.ParseDeclaration("transform: rotate(calc(max(45deg, 90deg)))")).Value);
+ Assert.AreEqual("rotate(45deg)", ((TransformProperty)CssConstructionFunctions.ParseDeclaration("transform: rotate(calc(clamp(0deg, 45deg, 90deg)))")).Value);
+ }
+
+ [TestMethod]
+ public void Color_HslHueCalcPlainNumber_FoldsToPlainNumber()
+ {
+ // hue accepts either an angle or a bare number (implicit degrees) - calc() should too.
+ var property = CssConstructionFunctions.ParseDeclaration("color: hsl(calc(100 + 20), 50%, 50%)");
+ Assert.IsTrue(property.HasValue);
+ Assert.AreEqual("hsl(120, 50%, 50%)", property.Value);
+ }
+
+ [TestMethod]
+ public void Transform_RotateCalcAngleAndLength_IsInvalid()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("transform: rotate(calc(45deg + 10px))");
+ Assert.IsFalse(property.HasValue);
+ }
+
+ // ── border-radius two-value form ─────────────────────────────────────────────────
+
+ [TestMethod]
+ public void BorderTopLeftRadius_CalcFirstValue_Legal()
+ {
+ var property = CssConstructionFunctions.ParseDeclaration("border-top-left-radius: calc(10px + 2px) 5px");
+ Assert.IsInstanceOfType