moxml 0.5.149 → 0.5.150

data/spec/consistency/xpath_idioms_spec.rb

@@ -42,11 +42,6 @@ RSpec.describe "XPath idioms across adapters" do
             Gem::Version.new(Leptris::VERSION) < Gem::Version.new("1.9.359.0")
           skip "binding #{Leptris::VERSION} predates the xmlns: fix (1.9.359)"
         end
-        if adapter_name == :oga
-          # oga's own Ruby XPath engine has no xmlns: default-ns
-          # support (third-party; explicit bindings work).
-          skip "D-01: oga's XPath engine does not implement the xmlns: idiom"
-        end
       end
 
       it "matches default-namespaced elements via the xmlns: prefix" do
@@ -62,6 +57,14 @@ RSpec.describe "XPath idioms across adapters" do
         expect(targets).to be_empty
       end
 
+      it "addresses the no-namespace default with an empty xmlns binding" do
+        doc = ctx.parse(
+          '<root xmlns="urn:a"><child xmlns="urn:b"><leaf xmlns=""/></child></root>',
+        )
+        leaf = doc.at_xpath("//xmlns:leaf", "xmlns" => "")
+        expect(leaf&.name).to eq("leaf")
+      end
+
       it "resolves attribute-terminal steps in every path position" do
         doc = ctx.parse(plain_xml)
         expect(doc.xpath("//a/@id").first&.value).to eq("x")
@@ -118,6 +121,21 @@ RSpec.describe "XPath idioms across adapters" do
         expect(doc.xpath("boolean(//b)")).to be(true)
         expect(doc.at_xpath("count(//a)")).to eq(1.0)
       end
+
+      # The live-tree contract: a sibling inserted after an XPath
+      # evaluation must be visible to at_xpath and xpath. leptris's
+      # node-set lane caches a document index that sibling insertions
+      # do not rebuild (engine bug, tracked upstream); the adapter
+      # routes such documents to the reference engine until a child
+      # insertion rebuilds the index.
+      it "answers at_xpath and xpath from the live tree after a sibling insertion" do
+        doc = ctx.parse("<r><a><b/></a></r>")
+        doc.xpath("//a")
+        doc.at("//a").next = "<c/>"
+        expect(doc.at("//c")&.name).to eq("c")
+        expect(doc.xpath("//c").map(&:name)).to eq(["c"])
+        expect(doc.at_xpath("count(//c)")).to eq(1.0)
+      end
     end
   end
 end

data/spec/integration/shared_examples/edge_cases.rb

@@ -80,15 +80,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
 
   describe "namespace edge cases" do
     it "handles default namespace changes" do
-      if context.config.adapter_name == :headed_ox
-        skip "HeadedOx limitation: Namespace methods not implemented in adapter. Requires Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
-      end
-      if context.config.adapter_name == :libxml
-        skip "LibXML cannot query empty default namespace with XPath (documented limitation)"
-      end
-      if context.config.adapter_name == :nokogiri
-        skip "Nokogiri XPath does not support querying empty namespace with xmlns prefix mapping"
-      end
       xml = <<~XML
         <root xmlns="http://default1.org">
           <child xmlns="http://default2.org">
@@ -103,10 +94,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
     end
 
     it "handles recursive namespace definitions" do
-      if context.config.adapter_name == :headed_ox
-        skip "HeadedOx limitation: Namespace methods not implemented in adapter. Requires Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
-      end
-
       xml = <<~XML
         <root xmlns:a="http://a.org">
           <a:child xmlns:a="http://b.org">

data/spec/moxml/adapter/leptris_spec.rb

@@ -184,12 +184,14 @@ RSpec.describe Moxml::Adapter::Leptris do
       end
     end
 
-    it "keeps comments in element serialization with tab units (leptris-ruby#115)" do
+    it "keeps comments in indented serialization with tab units (leptris-ruby#115)" do
       skip "requires the element unit fix (leptris 1.9.50+)" unless described_class::ELEMENT_UNIT_COMMENTS
 
+      # Element-level indentation is loud on this engine (D-09); the
+      # document lane exercises the same generator's unit handling.
       doc = ctx.parse(%(<r><a/><!-- c --></r>))
-      expect(doc.root.to_xml(indent: 1, indent_text: "\t"))
-        .to eq("<r>\n\t<a></a>\n\t<!-- c -->\n</r>")
+      expect(doc.to_xml(indent: 1, indent_text: "\t"))
+        .to eq("<r>\n\t<a></a>\n\t<!-- c -->\n</r>\n")
     end
 
     it "round-trips document-level PI mutations through serialization" do
@@ -846,4 +848,22 @@ RSpec.describe Moxml::Adapter::Leptris do
       expect(first.next_sibling.parent).to eq(doc.root)
     end
   end
+
+  describe "stale-index guard retirement (leptris-ruby#519)" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "auto-retires the guard when the engine invalidates its index" do
+      skip "requires an engine whose node-set index survives sibling insertion (leptris-ruby#519)" unless described_class.native_xpath_index_fixed?
+
+      doc = ctx.parse("<r><a/><b/></r>")
+      root = doc.root
+      _ = root.xpath("child::*") # populate the engine node-set index
+      b = root.children.to_a[1]
+      b.add_previous_sibling(doc.create_element("c"))
+
+      native = described_class.native_xpath(root.native, "child::*", nil)
+      expect(native).not_to be_nil
+      expect(native.to_a.map { |n| n.name.to_s }).to eq(%w[a c b])
+    end
+  end
 end

data/spec/moxml/adapter/shared_examples/adapter_contract.rb

@@ -457,10 +457,6 @@ RSpec.shared_examples "xml adapter" do
       end
 
       it "preserves and correctly handles multiple namespaces" do
-        if described_class.name.include?("Ox")
-          skip("Ox does not support namespace-aware XPath queries (documented limitation)")
-        end
-
         # Parse original XML
         doc = described_class.parse(xml).native
 
@@ -513,10 +509,6 @@ RSpec.shared_examples "xml adapter" do
       end
 
       it "preserves and correctly handles multiple namespaces" do
-        if described_class.name.include?("Ox")
-          skip("Ox does not support namespace-aware XPath queries (documented limitation)")
-        end
-
         # Parse original XML
         doc = described_class.parse(xml).native
 

data/spec/moxml/attribute_resolver_spec.rb

@@ -31,6 +31,39 @@ RSpec.describe Moxml::AttributeResolver do
       expect(described_class.resolve(element, "z:type")).to be_nil
       expect(described_class.resolve(element, "xmlns:q")).to be_nil
     end
+
+    # Namespaces 1.0 §5.2: the default namespace never applies to
+    # attributes. Engines that resolve unprefixed attributes against
+    # the default namespace must answer nil for it, or bare-name reads
+    # miss on every element under a default namespace.
+    it "never treats bare attributes as default-namespace members" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        d = Moxml.new(adapter_name).parse(%(<r xmlns="urn:a"><e id="1"/></r>))
+        e = d.root.children.find(&:element?)
+        expect(e["id"]).to eq("1"), "#{adapter_name}: bare read"
+        expect(e.attribute("id")&.value).to eq("1"),
+                                            "#{adapter_name}: resolver"
+        expect(e.attribute("id")&.namespace).to be_nil,
+                                                "#{adapter_name}: attribute namespace"
+      end
+    end
+
+    it "keeps bare reads on programmatically built default-namespaced trees" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        ctx = Moxml.new(adapter_name)
+        d = ctx.create_document
+        root = d.create_element("root")
+        root.add_namespace(nil, "urn:a")
+        d.add_child(root)
+        e = d.create_element("item")
+        e["id"] = "123"
+        root.add_child(e)
+
+        expect(e["id"]).to eq("123"), "#{adapter_name}: bare read"
+        expect(d.xpath('//xmlns:item[@id="123"]').to_a.size).to eq(1),
+                                                                "#{adapter_name}: xmlns predicate"
+      end
+    end
   end
 
   describe ".assign" do

data/spec/moxml/c14n/adapter_delegation_spec.rb

@@ -59,20 +59,47 @@ RSpec.describe "Moxml::C14n cross-adapter canonicalization" do
   end
 
   describe "document-level nodes keep document order" do
-    # oga surfaces the XML declaration as a <?xml?> PI and keeps the
-    # separator space in PI content (D-04); ox/headed_ox drop PI
-    # content on parse (D-05). Both are pre-existing parse-layer
-    # divergences, out of scope here.
-    let(:adapters) { Moxml::Adapter::AVAILABLE_ADAPTERS - %i[oga ox headed_ox] }
+    # ox/headed_ox drop PI content at parse (D-05), so content-bearing
+    # document-level PIs are pinned on the remaining adapters; the
+    # separator/newline rule itself is pinned on every adapter below
+    # (comments and empty-data PIs are common across all of them).
+    let(:content_adapters) do
+      Moxml::Adapter::AVAILABLE_ADAPTERS - %i[ox headed_ox]
+    end
 
     it "canonicalizes a leading PI before the root element" do
-      adapters.each do |adapter_name|
+      content_adapters.each do |adapter_name|
         doc = Moxml.new(adapter_name)
           .parse(%(<?xml version="1.0"?><?render mode="x"?><doc><e/></doc>))
         expect(Moxml::C14n.canonicalize(doc))
           .to eq(%(<?render mode="x"?>\n<doc><e></e></doc>))
       end
     end
+
+    it "uses exactly one newline between document-level nodes" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        doc = Moxml.new(adapter_name)
+          .parse(%(<?pi?><?pi2?><!--a--><doc/><!--b--><?pi3?>))
+        expect(Moxml::C14n.canonicalize(doc, with_comments: true))
+          .to eq(%(<?pi?>\n<?pi2?>\n<!--a-->\n<doc></doc>\n<!--b-->\n<?pi3?>))
+      end
+    end
+
+    it "never emits the XML declaration" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        doc = Moxml.new(adapter_name)
+          .parse(%(<?xml version="1.0" encoding="UTF-8"?><doc/>))
+        expect(Moxml::C14n.canonicalize(doc)).to eq("<doc></doc>")
+      end
+    end
+
+    it "collapses PI separator whitespace to one space" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        doc = Moxml.new(adapter_name).parse(%(<?pi  a  b?><doc/>))
+        expect(Moxml::C14n.canonicalize(doc))
+          .to eq(%(<?pi a  b?>\n<doc></doc>))
+      end
+    end
   end
 
   describe "native delegation" do

data/spec/moxml/c14n/character_encoding_spec.rb

@@ -12,25 +12,19 @@ LATIN1_XML = (+"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><r>caf\xE9</r>").
 BOM_XML = (+"\xEF\xBB\xBF<r/>").force_encoding("UTF-8")
 NFC_XML = (+"<r>caf\xC3\xA9</r>").force_encoding("UTF-8")
 
-# oga's parse layer leaks the declaration as a PI node and the BOM as
-# text (pre-existing, documented in the W3C examples spec).
-OGA_LEAK = %i[oga].freeze
-
 RSpec.describe "Moxml character encoding at the parse boundary" do
   Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
     context "with the #{adapter_name} adapter" do
       let(:ctx) { Moxml.new(adapter_name) }
 
-      unless OGA_LEAK.include?(adapter_name)
-        it "transcodes declared Latin-1 to UTF-8 bytes" do
-          doc = ctx.parse(LATIN1_XML.dup)
-          expect(Moxml::C14n.canonicalize(doc).bytes).to eq(CAF_E_UTF8)
-        end
+      it "transcodes declared Latin-1 to UTF-8 bytes" do
+        doc = ctx.parse(LATIN1_XML.dup)
+        expect(Moxml::C14n.canonicalize(doc).bytes).to eq(CAF_E_UTF8)
+      end
 
-        it "strips a leading UTF-8 BOM" do
-          doc = ctx.parse(BOM_XML.dup)
-          expect(Moxml::C14n.canonicalize(doc)).to eq("<r></r>")
-        end
+      it "strips a leading UTF-8 BOM" do
+        doc = ctx.parse(BOM_XML.dup)
+        expect(Moxml::C14n.canonicalize(doc)).to eq("<r></r>")
       end
 
       it "passes NFC content through without normalization" do

data/spec/moxml/c14n/comments_pis_spec.rb

@@ -48,18 +48,45 @@ RSpec.describe "C14N comments and PIs" do
   end
 
   describe "PIs at document level" do
-    # TODO.c14n/09: Document-level PIs (outside the document element) are
-    # not yet rendered correctly. The moxml PI parser mis-parses document-level
-    # PIs, and the DataModel.from_document path drops them. Fixing requires
-    # adapter-level work and is tracked separately.
-    it "renders PIs outside the document element (KNOWN LIMITATION)" do
-      skip "D-08: document-level PI rendering not yet implemented"
+    it "renders PIs outside the document element in document order" do
+      doc = ctx.parse(%(<?pi before?><root><?pi inner?></root><?pi after?>))
+      expect(Moxml::C14n.canonicalize(doc))
+        .to eq(%(<?pi before?>\n<root><?pi inner?></root>\n<?pi after?>))
+    end
+
+    it "uses exactly one newline between document-level nodes" do
+      doc = ctx.parse(%(<?pi a?><?pi b?><root/><?pi c?>))
+      expect(Moxml::C14n.canonicalize(doc))
+        .to eq(%(<?pi a?>\n<?pi b?>\n<root></root>\n<?pi c?>))
+    end
+
+    it "ignores whitespace between document-level nodes" do
+      # rexml retains the text node (D-15); the canonical form never
+      # includes whitespace outside the document element.
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        doc = Moxml.new(adapter_name).parse(%(<?pi?>\n<root/>\n<!--c-->))
+        expect(Moxml::C14n.canonicalize(doc, with_comments: true))
+          .to eq(%(<?pi?>\n<root></root>\n<!--c-->)), adapter_name.to_s
+      end
+    end
+
+    it "omits the XML declaration from the canonical form" do
+      doc = ctx.parse(%(<?xml version="1.0" encoding="UTF-8"?><root/>))
+      expect(Moxml::C14n.canonicalize(doc)).to eq("<root></root>")
     end
   end
 
   describe "comments at document level" do
-    it "renders document-level comments when with_comments: true (KNOWN LIMITATION)" do
-      skip "D-08: document-level comment rendering not yet implemented"
+    it "renders document-level comments when with_comments: true" do
+      doc = ctx.parse(%(<!--lead--><root><!--inner--></root><!--trail-->))
+      expect(Moxml::C14n.canonicalize(doc, with_comments: true))
+        .to eq(%(<!--lead-->\n<root><!--inner--></root>\n<!--trail-->))
+    end
+
+    it "keeps exactly one newline between a document-level PI and comment" do
+      doc = ctx.parse(%(<?pi x?><!--lead--><root/>))
+      expect(Moxml::C14n.canonicalize(doc, with_comments: true))
+        .to eq(%(<?pi x?>\n<!--lead-->\n<root></root>))
     end
   end
 end

data/spec/moxml/c14n/subset_spec.rb

@@ -43,9 +43,6 @@ COMMENTS_EXCLUDED_CASE = [
 ].freeze
 
 COMMENTS_PADDING_LOSS = %i[ox headed_ox].freeze
-# rexml's adapter xpath does not return comment()/text() node results
-# (pre-existing capability gap, same family for both axes).
-COMMENT_SELECTION_GAP = %i[rexml].freeze
 
 RSpec.describe "Moxml::C14n subset canonicalization" do
   # Node-set semantics follow the enveloped-signature interop
@@ -60,11 +57,6 @@ RSpec.describe "Moxml::C14n subset canonicalization" do
         let(:ctx) { Moxml.new(adapter_name) }
 
         C14N_SUBSET_CORPUS.each do |label, xml, xpath, expected|
-          next if label == "text selection" && adapter_name == :rexml
-
-          # rexml's adapter xpath does not return text nodes for
-          # text() node tests (D-07, pre-existing capability gap).
-
           it "canonicalizes #{label}" do
             doc = ctx.parse(xml)
             expect(Moxml::C14n.canonicalize_subset(doc, xpath)).to eq(expected)
@@ -73,10 +65,8 @@ RSpec.describe "Moxml::C14n subset canonicalization" do
 
         # ox/headed_ox strip comment content padding at the parse
         # layer (D-06, pre-existing, same family as their PI content
-        # loss); only the rendered-comment case depends on it. rexml's
-        # comment() selection gap (D-07) also only affects this case.
-        unless COMMENTS_PADDING_LOSS.include?(adapter_name) ||
-            COMMENT_SELECTION_GAP.include?(adapter_name)
+        # loss); only the rendered-comment case depends on it.
+        unless COMMENTS_PADDING_LOSS.include?(adapter_name)
           it COMMENTS_CASE[0] do
             doc = ctx.parse(COMMENTS_CASE[1])
             expect(Moxml::C14n.canonicalize_subset(doc, COMMENTS_CASE[2],

data/spec/moxml/c14n/w3c_examples_spec.rb

@@ -13,7 +13,6 @@ require "moxml/c14n"
 # Documented parse-layer divergences (skipped rows):
 # - ox/headed_ox expand 
 to LF, strip inter-element whitespace
 #   and comment padding at parse (out of scope here)
-# - oga keeps the target/content separator space in PI data
 W3C_FULL_FORMS = [
   ["attribute-value whitespace collapses to single spaces",
    "<doc>\n   <e   attr1=\"v1\"\n        attr2   =   \"v2\"\n    >   content   </e>\n</doc>",
@@ -55,11 +54,9 @@ RSpec.describe "Moxml::C14n W3C REC-xml-c14n examples" do
 
       W3C_FULL_FORMS.each_with_index do |(label, xml, expected), idx|
         # ox/headed_ox strip inter-element whitespace, expand &#xD;
-        # and pad comments at parse (D-05, D-06); oga keeps the PI
-        # separator space (D-04).
+        # and pad comments at parse (D-05, D-06).
         skip_shapes = { ox: [0, CR_SHAPE, PI_SHAPE],
-                        headed_ox: [0, CR_SHAPE, PI_SHAPE],
-                        oga: [PI_SHAPE] }[adapter_name] || []
+                        headed_ox: [0, CR_SHAPE, PI_SHAPE] }[adapter_name] || []
         next if skip_shapes.include?(idx)
 
         it "canonicalizes #{label}" do

data/spec/moxml/element_indent_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Element-level indentation is a declared capability (model, Serialization;
+# D-09): engines that cannot honor the knob raise the named AdapterError
+# instead of answering unindented output. indent: 0 and the no-option
+# path stay common — consumers use them for canonical shapes.
+RSpec.describe "element-level serialization indentation" do
+  it "honors a positive indent on engines that support it" do
+    %i[nokogiri rexml].each do |name|
+      doc = Moxml.new(name).parse("<r><a/></r>")
+      expect(doc.root.to_xml(indent: 2)).to include("\n"),
+                                            "#{name}: indent not honored"
+    end
+  end
+
+  it "raises the named AdapterError on engines that ignore the knob" do
+    %i[oga ox headed_ox libxml leptris].each do |name|
+      doc = Moxml.new(name).parse("<r><a/></r>")
+      expect { doc.root.to_xml(indent: 2) }
+        .to raise_error(Moxml::AdapterError, /indentation/),
+            "#{name}: silent unindented answer"
+    end
+  end
+
+  it "keeps indent: 0 and the no-option path common on every adapter" do
+    Moxml::Adapter::AVAILABLE_ADAPTERS.each do |name|
+      doc = Moxml.new(name).parse("<r><a/></r>")
+      expect(doc.root.to_xml(indent: 0)).to include("<a")
+      expect(doc.root.to_xml).to include("<a")
+    end
+  end
+end

data/spec/moxml/node_spec.rb

@@ -156,9 +156,6 @@ RSpec.describe Moxml::Node do
         end
 
         it "locates the node via its path" do
-          # Ox translates only a limited XPath subset (no positional predicates)
-          skip "D-12: ox xpath translation does not support positional predicates" if adapter_name == :ox
-
           expect(doc.at_xpath(title.path)).to eq(title)
         end
 

data/spec/moxml/relax_ng_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tempfile"
+
+# RELAX NG facade (TODO.sota/05): engines with an RNG validator
+# answer valid?/validate/validate_errors; engines without one raise
+# the named NotImplementedError at compile and answer supported?
+# without raising.
+RSpec.describe Moxml::RelaxNG do
+  RNG_SCHEMA = <<~RNG # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+    <element name="r" xmlns="http://relaxng.org/ns/structure/1.0">
+      <attribute name="a"><text/></attribute>
+    </element>
+  RNG
+
+  let(:valid_doc) { Moxml.new(:leptris).parse('<r a="x"/>') }
+  let(:invalid_doc) { Moxml.new(:leptris).parse("<r/>") }
+
+  it "answers supported? without raising on every adapter" do
+    Moxml::Adapter::AVAILABLE_ADAPTERS.each do |name|
+      ctx = Moxml.new(name)
+      expect { described_class.supported?(ctx) }.not_to raise_error
+    end
+  end
+
+  it "validates against a compiled schema and reports findings" do
+    ctx = Moxml.new(:leptris)
+    skip "leptris binding has no RNG face" unless described_class.supported?(ctx)
+
+    schema = ctx.relaxng(RNG_SCHEMA)
+    expect(schema.valid?(valid_doc)).to be(true)
+    expect(schema.validate(valid_doc)).to eq([])
+    expect(schema.valid?(invalid_doc)).to be(false)
+    error = schema.validate_errors(invalid_doc).first
+    expect(error[:message]).to include("missing required attribute")
+    expect(error[:line]).to eq(1)
+  end
+
+  it "compiles a schema from a file" do
+    ctx = Moxml.new(:leptris)
+    skip "leptris binding has no RNG face" unless described_class.supported?(ctx)
+
+    Tempfile.create(["schema", ".rng"]) do |file|
+      file.write(RNG_SCHEMA)
+      file.flush
+      schema = ctx.relaxng_file(file.path)
+      expect(schema.valid?(valid_doc)).to be(true)
+      expect(schema.valid?(invalid_doc)).to be(false)
+    end
+  end
+
+  it "raises a named NotImplementedError on engines without an RNG validator" do
+    ctx = Moxml.new(:nokogiri)
+    expect(described_class.supported?(ctx)).to be(false)
+    expect { ctx.relaxng(RNG_SCHEMA) }
+      .to raise_error(Moxml::NotImplementedError, /RELAX NG/)
+  end
+
+  it "names a malformed schema as a ValidationError" do
+    ctx = Moxml.new(:leptris)
+    skip "leptris binding has no RNG face" unless described_class.supported?(ctx)
+
+    expect { ctx.relaxng("<not-a-schema/>") }
+      .to raise_error(Moxml::ValidationError, /RELAX NG/)
+  end
+end

data/spec/moxml/sax_spec.rb

@@ -412,50 +412,39 @@ RSpec.describe Moxml::SAX do
       expect(handler.error_message).to match(/invalid|unclosed|premature|mismatch|not closed/i)
     end
 
-    it "documents CDATA limitation" do
-      # Ox SAX does not have separate CDATA events
-      # All CDATA content is delivered as text() events
-      skip "D-10: Ox SAX does not support separate CDATA events"
-
-      xml_with_cdata = "<root><![CDATA[special content]]></root>"
-
-      cdata_found = false
-      context.sax_parse(xml_with_cdata) do
-        cdata { |_text| cdata_found = true }
-      end
-
-      # This will fail because Ox doesn't support separate CDATA events
-      expect(cdata_found).to be true
+    it "declares CDATA event subscriptions loudly (D-10)" do
+      # Ox SAX has no separate CDATA events; a subscriber gets the
+      # named error rather than an incomplete stream.
+      expect do
+        context.sax_parse("<root><![CDATA[special content]]></root>") do
+          cdata { |_text| nil }
+        end
+      end.to raise_error(Moxml::NotImplementedError, /cdata/)
     end
 
-    it "documents comment limitation" do
-      # Ox SAX does not have separate comment events
-      skip "D-10: Ox SAX does not support separate comment events"
-
-      xml_with_comment = "<root><!-- comment --><data>content</data></root>"
-
-      comment_found = false
-      context.sax_parse(xml_with_comment) do
-        comment { |_text| comment_found = true }
-      end
-
-      # This will fail because Ox doesn't support comment events
-      expect(comment_found).to be true
+    it "declares comment event subscriptions loudly (D-10)" do
+      expect do
+        context.sax_parse("<root><!-- comment --><data>content</data></root>") do
+          comment { |_text| nil }
+        end
+      end.to raise_error(Moxml::NotImplementedError, /comment/)
     end
 
-    it "documents processing instruction limitation" do
-      # Ox SAX does not have separate PI events
-      skip "D-10: Ox SAX does not support separate processing instruction events"
-
-      xml_with_pi = '<?xml-stylesheet type="text/xsl" href="style.xsl"?><root/>'
+    it "declares PI event subscriptions loudly (D-10)" do
+      expect do
+        context.sax_parse('<?xml-stylesheet type="text/xsl" href="style.xsl"?><root/>') do
+          processing_instruction { |_target, _data| nil }
+        end
+      end.to raise_error(Moxml::NotImplementedError, /processing_instruction/)
+    end
 
-      pi_found = false
-      context.sax_parse(xml_with_pi) do
-        processing_instruction { |_target, _data| pi_found = true }
-      end
+    it "declares unsupported families loudly for class handlers too" do
+      handler = Class.new(Moxml::SAX::Handler) do
+        def on_cdata(_text); end
+      end.new
 
-      # This will fail because Ox doesn't support PI events
-      expect(pi_found).to be true
+      expect { context.sax_parse("<root/>", handler) }
+        .to raise_error(Moxml::NotImplementedError, /cdata/)
     end
   end
 
@@ -1024,46 +1013,28 @@ RSpec.describe Moxml::SAX do
       expect(handler.error_message).to match(/invalid|unclosed|premature|mismatch|not closed/i)
     end
 
-    it "documents CDATA limitation (inherited from Ox)" do
-      # HeadedOx inherits Ox's SAX implementation, which does not have separate CDATA events
-      skip "D-10: HeadedOx SAX (inherited from Ox) does not support separate CDATA events"
-
-      xml_with_cdata = "<root><![CDATA[special content]]></root>"
-
-      cdata_found = false
-      context.sax_parse(xml_with_cdata) do
-        cdata { |_text| cdata_found = true }
-      end
-
-      expect(cdata_found).to be true
+    it "declares CDATA event subscriptions loudly (inherited from Ox, D-10)" do
+      expect do
+        context.sax_parse("<root><![CDATA[special content]]></root>") do
+          cdata { |_text| nil }
+        end
+      end.to raise_error(Moxml::NotImplementedError, /cdata/)
     end
 
-    it "documents comment limitation (inherited from Ox)" do
-      # HeadedOx inherits Ox's SAX implementation, which does not have separate comment events
-      skip "D-10: HeadedOx SAX (inherited from Ox) does not support separate comment events"
-
-      xml_with_comment = "<root><!-- comment --><data>content</data></root>"
-
-      comment_found = false
-      context.sax_parse(xml_with_comment) do
-        comment { |_text| comment_found = true }
-      end
-
-      expect(comment_found).to be true
+    it "declares comment event subscriptions loudly (inherited from Ox, D-10)" do
+      expect do
+        context.sax_parse("<root><!-- comment --><data>content</data></root>") do
+          comment { |_text| nil }
+        end
+      end.to raise_error(Moxml::NotImplementedError, /comment/)
     end
 
-    it "documents processing instruction limitation (inherited from Ox)" do
-      # HeadedOx inherits Ox's SAX implementation, which does not have separate PI events
-      skip "D-10: HeadedOx SAX (inherited from Ox) does not support separate processing instruction events"
-
-      xml_with_pi = '<?xml-stylesheet type="text/xsl" href="style.xsl"?><root/>'
-
-      pi_found = false
-      context.sax_parse(xml_with_pi) do
-        processing_instruction { |_target, _data| pi_found = true }
-      end
-
-      expect(pi_found).to be true
+    it "declares PI event subscriptions loudly (inherited from Ox, D-10)" do
+      expect do
+        context.sax_parse('<?xml-stylesheet type="text/xsl" href="style.xsl"?><root/>') do
+          processing_instruction { |_target, _data| nil }
+        end
+      end.to raise_error(Moxml::NotImplementedError, /processing_instruction/)
     end
   end
 end