moxml 0.1.26 → 0.2.0

data/spec/moxml/attribute_resolver_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::AttributeResolver do
+  let(:context) { Moxml.new }
+  let(:doc) do
+    context.parse(<<~XML)
+      <root xmlns:p="http://x.org" xmlns:q="http://x.org">
+        <e q:type="namespaced" type="bare"/>
+      </root>
+    XML
+  end
+  let(:element) { doc.root.children.find(&:element?) }
+
+  describe ".resolve" do
+    it "matches bare names against no-namespace attributes only" do
+      expect(described_class.resolve(element, "type")&.value).to eq("bare")
+    end
+
+    it "matches prefixed names by expanded name" do
+      expect(described_class.resolve(element, "p:type")&.value)
+        .to eq("namespaced")
+      expect(described_class.resolve(element, "q:type")&.value)
+        .to eq("namespaced")
+    end
+
+    it "returns nil for undeclared prefixes and declarations" do
+      expect(described_class.resolve(element, "z:type")).to be_nil
+      expect(described_class.resolve(element, "xmlns:q")).to be_nil
+    end
+  end
+
+  describe ".assign" do
+    it "delegates xmlns declarations to the adapter" do
+      described_class.assign(element, "xmlns:r", "http://r.org")
+      expect(doc.to_xml).to include('xmlns:r="http://r.org"')
+    end
+
+    it "replaces the matching attribute in place" do
+      described_class.assign(element, "p:type", "rewritten")
+      expect(element["q:type"]).to eq("rewritten")
+      expect(element.attributes.size).to eq(2)
+    end
+
+    it "stores undeclared prefixes raw until they come into scope" do
+      described_class.assign(element, "z:type", "value")
+      expect(element["z:type"]).to be_nil
+
+      element.add_namespace("z", "http://z.org")
+      expect(element["z:type"]).to eq("value")
+    end
+  end
+
+  describe ".remove" do
+    it "removes by expanded name and returns the attribute" do
+      removed = described_class.remove(element, "p:type")
+      expect(removed.value).to eq("namespaced")
+      expect(element["q:type"]).to be_nil
+      expect(element["type"]).to eq("bare")
+    end
+
+    it "returns nil when nothing matches" do
+      expect(described_class.remove(element, "z:type")).to be_nil
+    end
+  end
+
+  describe ".attribute_test?" do
+    let(:attributes) { element.attributes }
+
+    it "applies Namespaces 1.0 §5.2 to bare names" do
+      bare = attributes.find { |a| a.value == "bare" }
+      namespaced = attributes.find { |a| a.value == "namespaced" }
+      expect(described_class.attribute_test?(element, bare, nil, "type"))
+        .to be(true)
+      expect(described_class.attribute_test?(element, namespaced, nil, "type"))
+        .to be(false)
+    end
+
+    it "matches prefixed tests by URI and accepts any local for nil" do
+      namespaced = attributes.find { |a| a.value == "namespaced" }
+      expect(described_class.attribute_test?(element, namespaced, "p", "type"))
+        .to be(true)
+      expect(described_class.attribute_test?(element, namespaced, "p", nil))
+        .to be(true)
+      expect(described_class.attribute_test?(element, namespaced, "z", "type"))
+        .to be(false)
+    end
+
+    it "treats :any as any namespace including none" do
+      bare = attributes.find { |a| a.value == "bare" }
+      expect(described_class.attribute_test?(element, bare, :any, "type"))
+        .to be(true)
+    end
+  end
+
+  describe ".attribute_test_uri?" do
+    it "matches the compile-time URI regardless of document prefixes" do
+      namespaced = element.attributes.find { |a| a.value == "namespaced" }
+      expect(described_class.attribute_test_uri?(
+               element, namespaced, "http://x.org", "type"
+             )).to be(true)
+      expect(described_class.attribute_test_uri?(
+               element, namespaced, "http://other.org", "type"
+             )).to be(false)
+    end
+  end
+end

data/spec/moxml/doctype_spec.rb

@@ -48,7 +48,7 @@ RSpec.describe Moxml::Doctype do
   end
 
   describe "parsing" do
-    %i[nokogiri oga rexml ox].each do |adapter_name|
+    %i[nokogiri oga rexml ox libxml].each do |adapter_name|
       context "with #{adapter_name} adapter" do
         let(:ctx) { Moxml.new(adapter_name) }
 

data/spec/moxml/entity_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Moxml::Entity do
+  describe ".preprocess_entities" do
+    it "marks non-standard entities and leaves the five standard ones" do
+      marked = described_class.preprocess_entities("a © b & c <")
+      expect(marked).to include("#{described_class::MARKER}copy;")
+      expect(marked).to include("&")
+      expect(marked).to include("<")
+    end
+
+    it "returns the input untouched when it contains no ampersand" do
+      input = "plain text"
+      expect(described_class.preprocess_entities(input)).to equal(input)
+    end
+
+    it "always returns UTF-8" do
+      binary = "caf\xC3\xA9 ©".b
+      result = described_class.preprocess_entities(binary)
+      expect(result.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it "returns an empty string for nil" do
+      expect(described_class.preprocess_entities(nil)).to eq("")
+    end
+  end
+
+  describe ".decode_entities" do
+    it "decodes numeric and standard named references in one pass" do
+      expect(described_class.decode_entities("AB&<"))
+        .to eq("AB&<")
+    end
+
+    it "preserves invalid numeric codepoints verbatim" do
+      expect(described_class.decode_entities("&#0;&#xD800;")).to eq("&#0;&#xD800;")
+    end
+
+    it "skips strings without ampersands" do
+      input = "plain"
+      expect(described_class.decode_entities(input)).to equal(input)
+    end
+  end
+
+  describe ".restore_entities" do
+    it "maps markers back to named references" do
+      restored = described_class.restore_entities(
+        "a#{described_class::MARKER}copy;b",
+      )
+      expect(restored).to eq("a&copy;b")
+    end
+
+    it "restores markers a native serializer rendered as character references" do
+      expect(described_class.restore_entities("a&#xFFFC;&#xFEFF;copy;b"))
+        .to eq("a&copy;b")
+    end
+
+    it "returns marker-free strings without a regex pass" do
+      input = "no markers here"
+      expect(described_class.restore_entities(input)).to equal(input)
+    end
+  end
+
+  describe Moxml::Entity::Reference do
+    it "round-trips as a serialized entity reference" do
+      expect(described_class.new("copy").to_xml).to eq("&copy;")
+    end
+
+    it "compares by name" do
+      reference = described_class.new("copy")
+      expect(reference).to eq(described_class.new("copy"))
+      expect(reference).not_to eq(described_class.new("nbsp"))
+    end
+  end
+end

data/spec/moxml/node_spec.rb

@@ -92,4 +92,108 @@ RSpec.describe Moxml::Node do
       expect(child.content).to eq("text")
     end
   end
+
+  describe "#ancestors" do
+    let(:doc) { context.parse("<library><section><book><title>Book 1</title></book></section></library>") }
+    let(:title) { doc.at_xpath("//title") }
+
+    it "returns ancestors from parent up to and including the document" do
+      ancestors = title.ancestors
+      expect(ancestors).to be_a(Moxml::NodeSet)
+      expect(ancestors.select(&:element?).map(&:name)).to eq(["book", "section", "library"])
+      expect(ancestors[3]).to be_a(Moxml::Document)
+    end
+
+    it "returns empty for the document" do
+      expect(doc.ancestors).to be_empty
+    end
+
+    it "returns the document for the root element" do
+      ancestors = doc.root.ancestors
+      expect(ancestors.size).to eq(1)
+      expect(ancestors.first).to be_a(Moxml::Document)
+    end
+  end
+
+  describe "#descendants" do
+    let(:doc) { context.parse("<section><book><title>Book 1</title></book></section>") }
+    let(:section) { doc.at_xpath("//section") }
+
+    it "returns all descendants excluding self" do
+      descendants = section.descendants
+      expect(descendants).to be_a(Moxml::NodeSet)
+      element_names = descendants.select(&:element?).map(&:name)
+      expect(element_names).to eq(["book", "title"])
+    end
+
+    it "includes text nodes" do
+      expect(section.descendants.any?(&:text?)).to be true
+    end
+
+    it "returns no elements for a leaf element" do
+      expect(doc.at_xpath("//title").descendants.select(&:element?)).to be_empty
+    end
+  end
+
+  describe "#path" do
+    %i[nokogiri oga rexml ox libxml].each do |adapter_name|
+      context "with #{adapter_name} adapter" do
+        let(:ctx) { Moxml.new(adapter_name) }
+        let(:doc) do
+          ctx.parse("<library><section><book id='1'/><book id='2'><title>Book 2</title></book></section></library>")
+        end
+        let(:first_book) { doc.root.children.find(&:element?).children.find { |c| c.element? && c.name == "book" && c["id"] == "1" } }
+        let(:second_book) { doc.root.children.find(&:element?).children.find { |c| c.element? && c.name == "book" && c["id"] == "2" } }
+        let(:title) { second_book.children.find(&:element?) }
+
+        it "builds the path without a predicate for uniquely named elements" do
+          expect(title.path).to eq("/library/section/book[2]/title")
+        end
+
+        it "adds a positional predicate for same-named siblings" do
+          expect(first_book.path).to eq("/library/section/book[1]")
+          expect(second_book.path).to eq("/library/section/book[2]")
+        end
+
+        it "locates the node via its path" do
+          # Ox translates only a limited XPath subset (no positional predicates)
+          skip "ox xpath translation does not support positional predicates" if adapter_name == :ox
+
+          expect(doc.at_xpath(title.path)).to eq(title)
+        end
+
+        it "returns / for the document" do
+          expect(doc.path).to eq("/")
+        end
+      end
+    end
+
+    it "raises for node types without a path representation" do
+      text = doc.root.children.first.children.first
+      expect { text.path }.to raise_error(Moxml::NotImplementedError, /element and document/)
+    end
+  end
+
+  describe "#line_number" do
+    %i[nokogiri oga rexml ox libxml].each do |adapter_name|
+      tracks_source_lines = adapter_name.eql?(:nokogiri) || adapter_name.eql?(:libxml)
+      context "with #{adapter_name} adapter" do
+        let(:ctx) { Moxml.new(adapter_name) }
+        let(:doc) do
+          ctx.parse("<?xml version='1.0'?>\n<library>\n  <book>\n    <title>Book 1</title>\n  </book>\n</library>\n")
+        end
+        let(:title) { doc.root.children.find(&:element?).children.find(&:element?) }
+
+        if tracks_source_lines
+          it "returns the 1-based source line" do
+            expect(title.line_number).to eq(4)
+          end
+        else
+          it "returns nil when the adapter does not track lines" do
+            expect(title.line_number).to be_nil
+          end
+        end
+      end
+    end
+  end
 end

data/spec/moxml/sax_entity_parity_spec.rb

@@ -0,0 +1,358 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Pins cross-adapter parity for entity-decoding in attribute values and
+# text content, across SAX, DOM, and build-then-serialize-then-reparse.
+# Previously the four adapters diverged: nokogiri/libxml SAX failed to
+# resolve "&#NN;"; rexml SAX delivered raw escaped strings; oga DOM
+# and SAX double-decoded.
+
+# Namespace-isolated container for the test data and the SAX capture
+# handler. Wrapping these in a module rather than declaring them as
+# top-level constants inside `RSpec.describe` keeps them out of the
+# global namespace and lets the spec reference them without tripping
+# the RSpec/* cops that forbid local-variable use inside examples.
+module SaxEntityParityFixtures
+  class CaptureHandler < Moxml::SAX::ElementHandler
+    attr_reader :first_attrs, :text
+
+    def initialize
+      super
+      @first_attrs = nil
+      @text = +""
+    end
+
+    def on_start_element(_name, attrs = {}, _namespaces = {})
+      @first_attrs = attrs.dup if @first_attrs.nil?
+    end
+
+    def on_characters(chunk)
+      @text << chunk
+    end
+  end
+
+  ADAPTERS = %i[nokogiri ox oga rexml libxml headed_ox].freeze
+
+  # Each row: [input XML, decoded attribute value, expected attribute
+  # value as it appears in the serialized XML]. The serialized form
+  # asserts what every adapter must emit byte-for-byte for the attribute.
+  ATTRIBUTE_CASES = {
+    "wrapped amp + decimal ref" => ['<doc x="&amp;#38;"/>', "&#38;", "&amp;#38;"],
+    "wrapped amp + hex ref" => ['<doc x="&amp;#x26;"/>', "&#x26;", "&amp;#x26;"],
+    "wrapped amp + non-std ref" => ['<doc x="&amp;copy;"/>', "&copy;", "&amp;copy;"],
+    "wrapped amp + lt" => ['<doc x="&amp;lt;"/>', "&lt;", "&amp;lt;"],
+    "wrapped amp + amp" => ['<doc x="&amp;amp;"/>', "&amp;", "&amp;amp;"],
+    "two amps" => ['<doc x="&amp;&amp;"/>', "&&", "&amp;&amp;"],
+    "plain amp" => ['<doc x="&amp;"/>', "&", "&amp;"],
+    "plain decimal ref" => ['<doc x="&#38;"/>', "&", "&amp;"],
+    "plain hex ref" => ['<doc x="&#x26;"/>', "&", "&amp;"],
+    "high codepoint" => ['<doc x="&#169;"/>', "©", "©"],
+    "no entities" => ['<doc x="plain"/>', "plain", "plain"],
+  }.freeze
+
+  # Each row: [input XML, decoded text, expected text as it appears in
+  # serialized XML].
+  TEXT_CASES = {
+    "text wrapped amp + decimal" => ["<doc>&amp;#38;</doc>", "&#38;", "&amp;#38;"],
+    "text wrapped amp + non-std" => ["<doc>&amp;copy;</doc>", "&copy;", "&amp;copy;"],
+    "text plain amp" => ["<doc>&amp;</doc>", "&", "&amp;"],
+  }.freeze
+
+  # XML 1.0 §2.6 — entity references inside PI content are NOT resolved.
+  # Every adapter must surface the literal source text. The libxml
+  # adapter previously decoded these five entities via a gsub chain in
+  # processing_instruction_content; pin each one explicitly.
+  PI_ENTITY_CASES = {
+    "&amp;" => "data &amp; more",
+    "&lt;" => "data &lt; more",
+    "&gt;" => "data &gt; more",
+    "&quot;" => "data &quot; more",
+    "&apos;" => "data &apos; more",
+  }.freeze
+
+  # Per-adapter overrides for the rebuild-path serialized form. Oga's
+  # set_attribute calls preprocess_entities which marks non-standard
+  # named entities so they survive serialization as "&name;" rather than
+  # being escaped to "&amp;name;". This is the entity-preservation
+  # feature documented in spec/moxml/adapter/entity_restoration_spec.rb
+  # and spec/moxml/adapter/oga_spec.rb — not a bug.
+  REBUILD_SERIALIZED_OVERRIDES = {
+    oga: {
+      "wrapped amp + non-std ref" => "&copy;",
+    },
+  }.freeze
+end
+
+RSpec.describe "SAX/DOM entity parity" do
+  SaxEntityParityFixtures::ADAPTERS.each do |adapter|
+    context "with #{adapter} adapter" do
+      let(:ctx) { Moxml.new(adapter) }
+
+      SaxEntityParityFixtures::ATTRIBUTE_CASES.each do |label, (xml, expected, expected_serialized)|
+        it "decodes attribute via SAX: #{label}" do
+          handler = SaxEntityParityFixtures::CaptureHandler.new
+          ctx.sax_parse(xml, handler)
+          expect(handler.first_attrs["x"]).to eq(expected)
+        end
+
+        it "decodes attribute via DOM: #{label}" do
+          expect(ctx.parse(xml).root["x"]).to eq(expected)
+        end
+
+        it "serializes attribute to expected XML form: #{label}" do
+          # End-to-end: parse → DOM access → set on fresh doc → serialize
+          # → assert exact serialized form. This pins what the consumer
+          # sees on the wire, not just what the parser delivers in memory.
+          parsed_value = ctx.parse(xml).root["x"]
+
+          doc2 = ctx.create_document
+          el = doc2.create_element("doc")
+          el["x"] = parsed_value
+          doc2.add_child(el)
+
+          serialized = doc2.to_xml.sub(/\A<\?[^>]*\?>\s*/, "")
+          expected_form = SaxEntityParityFixtures::REBUILD_SERIALIZED_OVERRIDES.dig(adapter, label) || expected_serialized
+          expect(serialized).to include(%(x="#{expected_form}"))
+        end
+
+        it "round-trips attribute through build+serialize+reparse: #{label}" do
+          parsed_value = ctx.parse(xml).root["x"]
+
+          doc2 = ctx.create_document
+          el = doc2.create_element("doc")
+          el["x"] = parsed_value
+          doc2.add_child(el)
+
+          serialized = doc2.to_xml.sub(/\A<\?[^>]*\?>/, "")
+          expect(ctx.parse(serialized).root["x"]).to eq(parsed_value)
+        end
+
+        it "re-serializes parsed document idempotently: #{label}" do
+          # Parse → serialize → re-parse → re-serialize → assert the two
+          # serializations match. This catches any non-idempotent
+          # mutations the adapter applies during the round-trip.
+          first = ctx.parse(xml).to_xml.sub(/\A<\?[^>]*\?>\s*/, "")
+          second = ctx.parse(first).to_xml.sub(/\A<\?[^>]*\?>\s*/, "")
+          expect(second).to eq(first)
+        end
+      end
+
+      SaxEntityParityFixtures::TEXT_CASES.each do |label, (xml, expected, expected_serialized)|
+        it "decodes text via SAX: #{label}" do
+          handler = SaxEntityParityFixtures::CaptureHandler.new
+          ctx.sax_parse(xml, handler)
+          expect(handler.text).to eq(expected)
+        end
+
+        it "decodes text via DOM: #{label}" do
+          expect(ctx.parse(xml).root.text).to eq(expected)
+        end
+
+        it "serializes text to expected XML form: #{label}" do
+          serialized = ctx.parse(xml).to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+          expect(serialized).to include(">#{expected_serialized}<")
+        end
+      end
+
+      it "does not double-escape '&' in a programmatically-built text node" do
+        # Pins the libxml customized Text#to_xml fix: an authored "&"
+        # must serialize to "&amp;" exactly once, never "&amp;amp;".
+        # Regression target for adapter/customized_libxml/text.rb where
+        # the previous implementation used #content (decoded text) and
+        # lost the "&" → "&amp;" escape, and earlier variants risked
+        # double-escaping on round-trip.
+        doc = ctx.create_document
+        el = doc.create_element("doc")
+        el.add_child("a & b")
+        doc.add_child(el)
+
+        serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+        expect(serialized).to include(">a &amp; b<")
+        expect(serialized).not_to include("&amp;amp;")
+
+        # And the round-trip must preserve the original text exactly.
+        reparsed_text = ctx.parse(serialized).root.text
+        expect(reparsed_text).to eq("a & b")
+      end
+
+      it "mutates in-tree text node content without double-escaping '&'" do
+        # Pins the libxml fix for set_text_content on attached text
+        # nodes: libxml-ruby's #content= setter pre-escapes the input,
+        # and #to_s escapes again on serialization. The adapter must
+        # replace the in-tree node with a fresh raw-storage node to
+        # avoid silent double-escape data corruption.
+        doc = ctx.create_document
+        el = doc.create_element("doc")
+        text = doc.create_text("placeholder")
+        el.add_child(text)
+        doc.add_child(el)
+
+        text.content = "a & b"
+        expect(text.content).to eq("a & b")
+
+        serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+        expect(serialized).to include(">a &amp; b<")
+        expect(serialized).not_to include("&amp;amp;")
+        expect(ctx.parse(serialized).root.text).to eq("a & b")
+      end
+
+      it "mutates in-tree PI content verbatim without escaping" do
+        # Pins the libxml fix for set_processing_instruction_content
+        # on attached PI nodes: libxml-ruby's #content= setter pre-
+        # escapes quotes and ampersands, but XML 1.0 §2.6 specifies
+        # PI content is verbatim — entity references are not resolved
+        # and no escaping is required on serialization.
+        doc = ctx.create_document
+        el = doc.create_element("doc")
+        pi = doc.create_processing_instruction("target", "placeholder")
+        el.add_child(pi)
+        doc.add_child(el)
+
+        pi.content = 'a " & b'
+        expect(pi.content.strip).to eq('a " & b')
+
+        serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+        expect(serialized).to include('a " & b?>')
+        expect(serialized).not_to include("&quot;")
+        expect(serialized).not_to include("&amp;")
+        reparsed = ctx.parse(serialized).root.children.find do |c|
+          c.is_a?(Moxml::ProcessingInstruction)
+        end
+        expect(reparsed.content.strip).to eq('a " & b')
+      end
+
+      it "mutates unparented text/PI content before adoption into the tree" do
+        # Pins the swap_native_in_place early-return when parent is nil:
+        # set_text_content / set_processing_instruction_content called
+        # before the node is added to any element must still replace the
+        # wrapper's @native with a fresh raw-storage node, so the value
+        # survives correctly once the node is later attached and serialized.
+        doc = ctx.create_document
+        el = doc.create_element("doc")
+
+        text = doc.create_text("placeholder")
+        text.content = "a & b"
+        pi = doc.create_processing_instruction("target", "placeholder")
+        pi.content = 'a " & b'
+
+        el.add_child(text)
+        el.add_child(pi)
+        doc.add_child(el)
+
+        serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+        expect(serialized).to include(">a &amp; b<")
+        expect(serialized).to include('<?target a " & b?>')
+        expect(serialized).not_to include("&amp;amp;")
+      end
+
+      # Regressions around &amp; appearing inside contexts that Oga's
+      # source-level preprocessor must not touch (CDATA, comments,
+      # DOCTYPE) — verified across adapters to ensure parity holds.
+      it "preserves literal &amp; inside CDATA" do
+        doc = ctx.parse("<doc><![CDATA[a &amp; b]]></doc>")
+        expect(doc.root.text).to eq("a &amp; b")
+      end
+
+      it "preserves literal &amp; inside comment" do
+        doc = ctx.parse("<doc><!-- a &amp; b --></doc>")
+        comment = doc.root.children.find { |c| c.is_a?(Moxml::Comment) }
+        expect(comment.content.strip).to eq("a &amp; b")
+      end
+
+      it "preserves literal U+FFFC U+FFFC user data in attribute" do
+        xml = "<doc x=\"\u{FFFC}\u{FFFC} test\"/>"
+        expect(ctx.parse(xml).root["x"]).to eq("\u{FFFC}\u{FFFC} test")
+      end
+
+      it "preserves literal U+FDD0 U+FDD0 user data in attribute" do
+        # Single noncharacters near the Oga marker codepoints — must not
+        # collide with the internal DEFAULT_AMP_MARKER sentinel.
+        xml = "<doc x=\"\u{FDD0}\u{FDD0} test\"/>"
+        expect(ctx.parse(xml).root["x"]).to eq("\u{FDD0}\u{FDD0} test")
+      end
+
+      it "preserves the exact Oga DEFAULT_AMP_MARKER sequence in attribute (no amp)" do
+        # User data matching the default Oga marker codepoints with NO
+        # &amp; in the input — restore must not run, so the sequence
+        # survives intact.
+        xml = "<doc x=\"\u{FDD0}\u{FDD1}\u{FDD2} plain\"/>"
+        expect(ctx.parse(xml).root["x"]).to eq("\u{FDD0}\u{FDD1}\u{FDD2} plain")
+      end
+
+      it "preserves the exact Oga DEFAULT_AMP_MARKER sequence in attribute (with amp)" do
+        # User data matching the default Oga marker codepoints alongside
+        # an &amp; that the preprocessor would otherwise substitute.
+        # The adapter must pick a marker not present in user data so
+        # restore doesn't corrupt the original sequence.
+        xml = "<doc x=\"\u{FDD0}\u{FDD1}\u{FDD2} &amp; foo\"/>"
+        expect(ctx.parse(xml).root["x"]).to eq("\u{FDD0}\u{FDD1}\u{FDD2} & foo")
+      end
+
+      it "preserves the exact Oga DEFAULT_AMP_MARKER sequence in text" do
+        xml = "<doc>\u{FDD0}\u{FDD1}\u{FDD2} &amp; foo</doc>"
+        expect(ctx.parse(xml).root.text).to eq("\u{FDD0}\u{FDD1}\u{FDD2} & foo")
+      end
+
+      it "handles DOCTYPE with '[' in quoted system ID" do
+        # System ID containing a literal "[" before the internal subset
+        # opener — quote-aware DOCTYPE terminator must not pick "]>"
+        # based on the bracket inside the quoted string.
+        xml = %(<!DOCTYPE root SYSTEM "has[bracket"><root x="&amp;#38;"/>)
+        expect(ctx.parse(xml).root["x"]).to eq("&#38;")
+      end
+
+      it "handles bare DOCTYPE with '>' in quoted system ID" do
+        # Bare DOCTYPE (no internal subset) — the terminator is ">".
+        # A literal ">" inside the quoted SYSTEM id must not be treated
+        # as the end of the declaration. For the Oga adapter this also
+        # exercises find_block_terminator's quote-aware ">" scan; if
+        # the bare-DOCTYPE end was misidentified, the preprocessor
+        # would rewrite "&amp;" inside the remaining quoted ID region
+        # to DEFAULT_AMP_MARKER and leak it into the serialized doctype.
+        xml = %(<!DOCTYPE root SYSTEM "a>b&amp;c"><root x="&amp;#38;"/>)
+        expect(ctx.parse(xml).root["x"]).to eq("&#38;")
+      end
+
+      it "handles DOCTYPE with ']>' inside a quoted entity value" do
+        # Quote-aware DOCTYPE terminator must skip past a literal "]>"
+        # appearing inside a quoted ExternalID / ENTITY value so the
+        # internal subset terminator is matched correctly. For the Oga
+        # adapter this also exercises the source-level DOCTYPE skipper;
+        # native-DOCTYPE parsers must reach the same result.
+        xml = '<!DOCTYPE root [ <!ENTITY foo "]>"> ]><root x="&amp;#38;"/>'
+        expect(ctx.parse(xml).root["x"]).to eq("&#38;")
+      end
+
+      SaxEntityParityFixtures::PI_ENTITY_CASES.each do |entity_label, payload|
+        it "preserves literal #{entity_label} inside processing instruction" do
+          doc = ctx.parse("<doc><?target #{payload}?></doc>")
+          pi = doc.root.children.find { |c| c.is_a?(Moxml::ProcessingInstruction) }
+          expect(pi.content.strip).to eq(payload)
+        end
+      end
+    end
+  end
+
+  # Cross-adapter equivalence: feed the same XML into every adapter and
+  # assert all of them emit the same serialized attribute form. Catches
+  # any regression where one adapter starts to deviate from the rest.
+  describe "cross-adapter serialization equivalence" do
+    def serialize_via(adapter, xml)
+      ctx = Moxml.new(adapter)
+      ctx.parse(xml).to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+    end
+
+    SaxEntityParityFixtures::ATTRIBUTE_CASES.each do |label, (xml, _expected, expected_serialized)|
+      it "every adapter emits the same attribute form: #{label}" do
+        results = SaxEntityParityFixtures::ADAPTERS.to_h { |a| [a, serialize_via(a, xml)] }
+        results.each do |a, out|
+          expect(out).to(
+            include(%(x="#{expected_serialized}")),
+            "#{a} produced #{out.inspect}",
+          )
+        end
+      end
+    end
+  end
+end