moxml 0.5.148 → 0.5.149

data/spec/consistency/metamorphic_properties_spec.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/input_taxonomy"
+require "support/input_generator"
+
+# Metamorphic property suite (TODO.sota/02): generated evidence over
+# the 01 taxonomy's vocabulary, seeded per run — SOTA_FUZZ_SEEDS
+# (default fixed, identical cases every CI run; the nightly fuzz leg
+# passes a random comma-separated list) and SOTA_FUZZ_CASES per seed
+# (bounded per leg).
+#
+# M1 round trip, M2 c14n idempotence, M3 document-order/union order,
+# M4 serialization shape, M5 cross-adapter answer equality modulo the
+# register; the malformed class raises the named ParseError
+# everywhere. Failures name the case id ("gen <seed>/<i>") —
+# reproducible at that seed and index — and the cell.
+RSpec.describe "metamorphic properties (generated, seeded)" do
+  let(:fuzz_seeds) do
+    if ENV.key?("SOTA_FUZZ_SEEDS")
+      ENV.fetch("SOTA_FUZZ_SEEDS").split(",").map(&:to_i)
+    else
+      [20261020]
+    end
+  end
+
+  let(:fuzz_count) { Integer(ENV.fetch("SOTA_FUZZ_CASES", "200")) }
+
+  let(:cases) do
+    fuzz_seeds.flat_map do |seed|
+      InputGenerator.cases(seed: seed, count: fuzz_count)
+    end
+  end
+
+  def snapshot(doc)
+    {
+      nodes: doc.traverse.to_a.grep_v(Moxml::Document).count,
+      root: doc.root&.name,
+      text: doc.text,
+      xpath: doc.xpath("//*").to_a.count,
+    }
+  end
+
+  def compact(snap)
+    snap.except(:nodes).merge(text: snap[:text].gsub(/\s+/, ""))
+  end
+
+  def exempt?(input, face, name)
+    input.features.any? do |feature|
+      InputGenerator::FEATURE_EXEMPT.dig(feature, face, name)
+    end
+  end
+
+  it "M1: keeps the round trip stable per adapter over generated inputs" do
+    cases.each do |input|
+      next unless input.well_formed
+
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |name|
+        begin
+          ctx = Moxml.new(name)
+          first = snapshot(ctx.parse(input.xml))
+          second = snapshot(ctx.parse(ctx.parse(input.xml).to_xml(indent: 0)))
+        rescue Moxml::Error, NotImplementedError, LoadError
+          next # adapter unavailable or a named guard excuses the leg
+        end
+        expect(compact(second)).to eq(compact(first)),
+                                   "#{input.id} round-trip drifted on " \
+                                   "#{name}: #{first.inspect} vs " \
+                                   "#{second.inspect}"
+      end
+    end
+  end
+
+  it "M2: canonicalization is idempotent (c14n∘c14n == c14n)" do
+    c14n = Moxml::C14n::Inclusive10.new
+    cases.each do |input|
+      next unless input.well_formed
+
+      once = c14n.canonicalize(input.xml)
+      expect(c14n.canonicalize(once)).to eq(once),
+                                         "#{input.id}: c14n is not " \
+                                         "idempotent"
+    end
+  end
+
+  it "M3: XPath unions answer in first-encounter (document) order" do
+    # XPath 1.0 unprefixed name tests match no-namespace elements
+    # only (processing model, "Names and namespaces") — the union
+    # property is scoped to cases an unprefixed query can address.
+    addressed = cases.select do |input|
+      input.well_formed && !input.features.include?(:default_ns)
+    end
+    addressed.each do |input|
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |name|
+        begin
+          doc = Moxml.new(name).parse(input.xml)
+          union = doc.xpath("//a | //b").to_a.map(&:name)
+        rescue Moxml::Error, NotImplementedError, LoadError
+          next # adapter unavailable in this environment
+        end
+        wanted = %w[a b]
+        doc_order = doc.traverse.to_a
+          .grep(Moxml::Element)
+          .map(&:name)
+          .select { |n| wanted.include?(n) }
+        expect(union).to eq(doc_order),
+                         "#{input.id}: union order diverges from document " \
+                         "order on #{name}: #{union.inspect} vs " \
+                         "#{doc_order.inspect}"
+      end
+    end
+  end
+
+  it "M4: to_html and to_xhtml hold their serialization shape" do
+    cases.each do |input|
+      next if !input.well_formed || input.voids.empty?
+
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |name|
+        begin
+          doc = Moxml.new(name).parse(input.xml)
+          html = doc.to_html
+          xhtml = doc.to_xhtml
+        rescue Moxml::Error, NotImplementedError, LoadError
+          next # the HTML face is adapter-optional (loud raise where absent)
+        end
+        expect(html).not_to include("<?xml"),
+                            "#{input.id}: to_html declared XML on #{name}"
+        input.voids.each do |v|
+          expect(html).not_to match(%r{<#{v}\b[^>]*/>}),
+                              "#{input.id}: to_html self-closed void <#{v}> " \
+                              "on #{name}"
+        end
+        # "none of the HTML short forms": a bare <br> is not XML,
+        # so the strict re-parse is the rigorous check (self-closed
+        # and paired forms are both legal XHTML).
+        expect { Moxml.new(:leptris).parse(xhtml, strict: true) }
+          .not_to raise_error,
+                  "#{input.id}: to_xhtml left an HTML short form on " \
+                  "#{name}: #{xhtml[0, 120].inspect}"
+      end
+    end
+  end
+
+  it "M5: every adapter answers generated inputs identically, modulo the register" do
+    cases.each do |input|
+      next unless input.well_formed
+
+      per = Moxml::Adapter::AVAILABLE_ADAPTERS.filter_map do |name|
+        [name, snapshot(Moxml.new(name).parse(input.xml))]
+      rescue Moxml::Error, NotImplementedError, LoadError
+        nil # adapter unavailable in this environment
+      end.to_h
+      expect(per.keys.count).to be >= 2
+
+      base_name = per.keys.first
+      base = per[base_name]
+      per.each do |name, got|
+        base.except(:text).each_key do |face|
+          next if exempt?(input, face, name)
+
+          expect(got[face]).to eq(base[face]),
+                               "#{input.id}/#{face} differs on #{name} vs " \
+                               "#{base_name}: #{got[face].inspect} vs " \
+                               "#{base[face].inspect} — fix it or register " \
+                               "a divergence and exempt the cell"
+        end
+        next if exempt?(input, :text, name)
+
+        expect(got[:text]).to eq(base[:text]),
+                              "#{input.id}/text differs on #{name} vs " \
+                              "#{base_name}: #{got[:text].inspect} vs " \
+                              "#{base[:text].inspect} — fix it or register " \
+                              "a divergence and exempt the cell"
+      end
+    end
+  end
+
+  it "raises the named parse error on generated malformed input, everywhere" do
+    cases.each do |input|
+      next if input.well_formed
+
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |name|
+        # oga's strict lane is lexer-strict, not
+        # well-formedness-strict (D-17) — structural malformations
+        # parse there; every other adapter must raise the named error.
+        next if name == :oga # D-17
+
+        expect { Moxml.new(name).parse(input.xml, strict: true) }
+          .to raise_error(Moxml::ParseError),
+              "#{input.id}: #{name} accepted malformed input or raised " \
+              "outside the named ParseError contract"
+      end
+    end
+  end
+end

data/spec/consistency/metamorphic_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/xml_generator"
+
+# Metamorphic conformance (TODO.sota/02): properties over GENERATED
+# documents — no expected outputs needed, only relations that must
+# hold for every input. Seeded: a failing seed reproduces locally.
+# Nightly legs sweep larger seeds (SOTA_FUZZ_SEEDS).
+RSpec.describe "metamorphic relations over generated documents" do
+  SEEDS = (ENV.key?("SOTA_FUZZ_SEEDS") ? ENV.fetch("SOTA_FUZZ_SEEDS").split(",").map(&:to_i) : [1, 2, 3]) # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+  DOCS_PER_SEED = 10 # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+  def adapters
+    Moxml::Adapter::AVAILABLE_ADAPTERS - [:headed_ox]
+  end
+
+  def docs
+    @docs ||= SEEDS.flat_map do |seed|
+      (0...DOCS_PER_SEED).map do |i|
+        [:"#{seed}_#{i}", XmlGenerator.generate((seed * 1000) + i)]
+      end
+    end
+  end
+
+  def snapshot_structure(doc)
+    doc.xpath("//*").to_a.map(&:name)
+  end
+
+  def element_attr_set(doc)
+    doc.xpath("//*").to_a.map do |n|
+      n.attribute_pairs.map { |k, v| [k, v] }.sort
+    end
+  end
+
+  # M1: parse∘serialize identity on the information set
+  it "M1 round-trips every generated document on every adapter" do
+    docs.each do |seed_tag, xml|
+      adapters.each do |name|
+        begin
+          ctx = Moxml.new(name)
+          doc = ctx.parse(xml)
+        rescue Moxml::Error, NotImplementedError, LoadError
+          next
+        end
+        first = snapshot_structure(doc)
+        again = ctx.parse(doc.to_xml(indent: 0))
+        expect(snapshot_structure(again)).to eq(first),
+                                             "M1 drift #{seed_tag}/#{name}"
+      end
+    end
+  end
+
+  # M2: canonicalization idempotence (the Ruby reference + native
+  # delegations answer one canonical form; re-canonicalizing it is
+  # the identity).
+  it "M2 canonicalization is idempotent on every adapter" do
+    docs.each do |seed_tag, xml|
+      adapters.each do |name|
+        begin
+          doc = Moxml.new(name).parse(xml)
+          once = Moxml::C14n.canonicalize(doc)
+          twice = Moxml::C14n.canonicalize(Moxml.new(name).parse(once))
+        rescue Moxml::Error, NotImplementedError, LoadError
+          next
+        end
+        expect(twice).to eq(once), "M2 drift #{seed_tag}/#{name}"
+      end
+    end
+  end
+
+  # M3: document order — XPath element results equal the pre-order
+  # walk's element sequence.
+  it "M3 XPath results preserve document order on every adapter" do
+    docs.each do |seed_tag, xml|
+      adapters.each do |name|
+        begin
+          doc = Moxml.new(name).parse(xml)
+          via_xpath = doc.xpath("//*").to_a.map(&:name)
+          via_walk = []
+          doc.traverse { |n| via_walk << n.name if n.node_type == :element }
+        rescue Moxml::Error, NotImplementedError, LoadError
+          next
+        end
+        expect(via_xpath).to eq(via_walk), "M3 drift #{seed_tag}/#{name}"
+      end
+    end
+  end
+
+  # M4: serialization shape invariants (per shape).
+  it "M4 keeps the shape contracts on every adapter" do
+    docs.each do |seed_tag, xml|
+      adapters.each do |name|
+        begin
+          ctx = Moxml.new(name)
+          doc = ctx.parse(xml)
+          xhtml = doc.to_xhtml
+        rescue Moxml::Error, NotImplementedError, LoadError
+          next # loud contracts (no HTML engine) are pinned elsewhere
+        end
+        expect(xhtml).not_to include("<!DOCTYPE"),
+                             "M4 #{seed_tag}/#{name}: xhtml grew a doctype"
+        expect(xhtml).not_to include("<?xml"),
+                             "M4 #{seed_tag}/#{name}: xhtml grew a declaration"
+        # The XHTML shape re-parses with the same element set (the
+        # slash forms are well-formed XML).
+        expect(snapshot_structure(ctx.parse(xhtml)))
+          .to eq(snapshot_structure(doc)),
+              "M4 #{seed_tag}/#{name}: xhtml round-trip drifted"
+      end
+    end
+  end
+
+  # M5: adapter-adapter equivalence on the structural information set
+  # (element sequence + attribute sets). Text-level equivalence over
+  # generated docs rides the taxonomy differential's registered
+  # exemptions (D-13/D-14 whitespace/PI families).
+  it "M5 structural equivalence across adapters" do
+    docs.each do |seed_tag, xml|
+      per = adapters.filter_map do |name|
+        doc = Moxml.new(name).parse(xml)
+        [name, snapshot_structure(doc), element_attr_set(doc)]
+      rescue Moxml::Error, NotImplementedError, LoadError
+        nil
+      end
+      next if per.size < 2
+
+      base_name, base_struct, base_attrs = per.first
+      per.each do |name, struct, attrs|
+        expect(struct).to eq(base_struct),
+                          "M5 structure drift #{seed_tag}/#{name} vs " \
+                          "#{base_name}"
+        expect(attrs).to eq(base_attrs),
+                         "M5 attribute drift #{seed_tag}/#{name} vs " \
+                         "#{base_name}"
+      end
+    end
+  end
+end

data/spec/consistency/model_coverage_audit_spec.rb

@@ -12,47 +12,60 @@ require "spec_helper"
 RSpec.describe "model coverage matrix" do
   MODEL_MATRIX = { # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
     "document order and children listing" => {
+      section: "Document order and traversal",
       pin: "spec/consistency/adapter_parity_spec.rb",
     },
     "name resolution" => {
+      section: "Names and namespaces",
       pin: "spec/consistency/xpath_idioms_spec.rb",
     },
     "namespace resolution and bindings normalization" => {
+      section: "Names and namespaces",
       pin: "spec/consistency/xpath_idioms_spec.rb",
     },
     "attribute access" => {
+      section: "Access semantics",
       pin: "spec/moxml/attribute_resolver_spec.rb",
     },
     "text/content/raw_content" => {
+      section: "Access semantics",
       pin: "spec/moxml/text_spec.rb",
     },
     "parsing modes and diagnostics" => {
+      section: "Parsing",
       pin: "spec/moxml/document_parse_diagnostics_spec.rb",
     },
     "EOL normalization" => {
+      section: "Parsing",
       pin: "spec/consistency/eol_normalization_spec.rb",
       exempt: { oga: "D-02", ox: "D-03" },
     },
     "entity modes" => {
+      section: "Parsing",
       pin: "spec/moxml/entity_spec.rb",
     },
     "XPath evaluation and declared idioms" => {
+      section: "XPath evaluation",
       pin: "spec/consistency/xpath_idioms_spec.rb",
       exempt: { oga: "D-01" },
     },
     "serialization shapes (xml/html/xhtml)" => {
+      section: "Serialization",
       pin: "spec/moxml/xhtml_output_spec.rb",
     },
     "indentation knobs" => {
+      section: "Serialization",
       pin: "spec/moxml/to_html_spec.rb",
       exempt: { oga: "D-09", ox: "D-09", headed_ox: "D-09",
                 libxml: "D-09", leptris: "D-09" },
     },
     "canonicalization" => {
+      section: "Canonicalization",
       pin: "spec/moxml/c14n/adapter_delegation_spec.rb",
       exempt: { oga: "D-04", ox: "D-05", headed_ox: "D-05" },
     },
     "XSLT" => {
+      section: "XSLT",
       pin: "spec/consistency/xslt_spec.rb",
       loud: { oga: "Moxml::NotImplementedError",
               ox: "Moxml::NotImplementedError",
@@ -61,12 +74,15 @@ RSpec.describe "model coverage matrix" do
               libxml: "Moxml::NotImplementedError" },
     },
     "SAX" => {
+      section: "SAX",
       pin: "spec/moxml/sax_spec.rb",
     },
     "materialization" => {
+      section: "Materialization",
       pin: "spec/moxml/plan_conformance_spec.rb",
     },
     "loud capability contracts" => {
+      section: "Errors and loud degradation",
       pin: "spec/consistency/loud_degradation_spec.rb",
     },
   }.freeze
@@ -110,4 +126,96 @@ RSpec.describe "model coverage matrix" do
     expect(bad).to be_empty,
                    "loud cells must name Moxml errors: #{bad.join('; ')}"
   end
+
+  # Model-derived governance: the matrix is generated FROM the model
+  # doc's section headings, in both directions. A new section in
+  # processing-model.adoc without a matrix citation (or an explicit
+  # non-face declaration) fails this audit; a matrix citation whose
+  # section vanished fails too.
+  MODEL_DOC = "docs/_references/processing-model.adoc" # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+
+  NON_FACE_SECTIONS = [ # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+    "Status and precedence",
+    "Mission and invariant",
+    "Object model",
+    "Performance: a declared, non-semantic channel",
+  ].freeze
+
+  def model_sections
+    File.readlines(MODEL_DOC).filter_map do |line|
+      line[/\A=== (\S.*)$/, 1]&.strip
+    end.uniq
+  end
+
+  it "cites an existing model section for every face family" do
+    sections = model_sections
+    unknown = MODEL_MATRIX.filter_map do |family, cell|
+      section = cell[:section]
+      next "#{family}: nil" if section.nil?
+
+      "#{family}: #{section.inspect}" unless sections.include?(section)
+    end
+    expect(unknown).to be_empty,
+                       "matrix families citing missing model sections: #{unknown.join('; ')}"
+  end
+
+  it "covers or declares every model section" do
+    cited = MODEL_MATRIX.values.filter_map { |cell| cell[:section] }
+    uncovered = model_sections.reject do |section|
+      cited.include?(section) || NON_FACE_SECTIONS.include?(section)
+    end
+    expect(uncovered).to be_empty,
+                         "model sections with no coverage matrix family " \
+                         "(add a family or declare non-face): #{uncovered.join('; ')}"
+  end
+
+  it "declares non-face sections that actually exist in the model doc" do
+    stale = NON_FACE_SECTIONS.reject { |s| model_sections.include?(s) }
+    expect(stale).to be_empty,
+                     "non-face declarations citing missing sections: #{stale.join('; ')}"
+  end
+
+  # Bidirectional linkage (TODO.sota/03): the model doc, the pins, and
+  # the reference form one checkable triangle. Every pin cites the
+  # section it enforces; every citation names a section that exists.
+  PIN_CITATION = /Processing model §(.+?) \(normative\)/ # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+
+  def pin_citations(path)
+    File.readlines(path).filter_map { |line| line[PIN_CITATION, 1]&.strip }
+  end
+
+  it "has every pin cite the model section it enforces" do
+    missing = MODEL_MATRIX.filter_map do |family, cell|
+      next unless cell[:pin] && File.exist?(cell[:pin])
+
+      "#{family}: #{cell[:pin]}" unless pin_citations(cell[:pin])
+        .include?(cell[:section])
+    end
+    expect(missing).to be_empty,
+                       "pins must cite their model section " \
+                       "(# Processing model §<section>): #{missing.join('; ')}"
+  end
+
+  it "never cites a model section that does not exist" do
+    sections = model_sections
+    orphans = MODEL_MATRIX.filter_map { |_, cell| cell[:pin] }.uniq.flat_map do |path|
+      next [] unless File.exist?(path)
+
+      pin_citations(path).reject { |section| sections.include?(section) }
+        .map { |section| "#{path}: #{section}" }
+    end
+    expect(orphans).to be_empty,
+                       "pin citations naming missing sections: #{orphans.join('; ')}"
+  end
+
+  it "cites every face section from at least one pin" do
+    cited = MODEL_MATRIX.filter_map { |_, cell| cell[:pin] }.uniq.flat_map do |path|
+      File.exist?(path) ? pin_citations(path) : []
+    end
+    uncovered = model_sections.reject do |section|
+      cited.include?(section) || NON_FACE_SECTIONS.include?(section)
+    end
+    expect(uncovered).to be_empty,
+                         "model sections no pin cites: #{uncovered.join('; ')}"
+  end
 end

data/spec/consistency/reference_differential_spec.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/input_taxonomy"
+
+# Executable-reference differential (TODO.sota/03): every adapter's
+# answer for each taxonomy input is compared against the pure-Ruby
+# reference implementation (Moxml::Reference), not against another
+# adapter. Faces: document order, children listing, access truth
+# table, attributes, PI/comment data, and serialization round-trip.
+# Cells that differ cite a registered divergence (D-NN) or the
+# adapter is fixed.
+RSpec.describe "executable reference differential" do
+  let(:references) { {} }
+
+  def adapters
+    Moxml::Adapter::AVAILABLE_ADAPTERS.uniq
+  end
+
+  def exempt?(input, face, adapter)
+    InputTaxonomy::EXEMPT.dig(input.id, face, adapter)
+  end
+
+  def reference_for(input)
+    references[input.id] ||= Moxml::Reference.parse(input.xml)
+  end
+
+  def adapter_document(name, xml)
+    Moxml.new(name).parse(xml)
+  rescue Moxml::Error, NotImplementedError, LoadError
+    nil # unavailable in this environment
+  end
+
+  def elements(doc)
+    doc.xpath("//*").to_a
+  end
+
+  def reference_elements(reference)
+    rows = []
+    reference.each_node { |node| rows << node if node.element? }
+    rows
+  end
+
+  def pi_rows(doc)
+    doc.traverse.filter_map do |node|
+      [node.name, node.content] if node.node_type == :processing_instruction
+    end
+  end
+
+  def comment_rows(doc)
+    doc.traverse.filter_map do |node|
+      node.content if node.node_type == :comment
+    end
+  end
+
+  def compact(text)
+    text.to_s.gsub(/\s+/, "")
+  end
+
+  it "answers document order and children listing like the reference" do
+    InputTaxonomy.well_formed.each do |input|
+      ref = reference_for(input)
+      expected_order = Moxml::Reference.element_names(ref)
+      expected_children = Moxml::Reference.child_element_names(ref)
+      adapters.each do |name|
+        doc = adapter_document(name, input.xml)
+        next unless doc # unavailable
+        next if exempt?(input, :nodes, name)
+
+        got_order = elements(doc).map(&:name)
+        expect(got_order).to eq(expected_order),
+                             "#{input.id}/#{name}: document order differs " \
+                             "from the reference: #{got_order.inspect} vs " \
+                             "#{expected_order.inspect}"
+
+        got_children = elements(doc).map do |element|
+          element.children.grep(Moxml::Element).map(&:name)
+        end
+        expect(got_children).to eq(expected_children),
+                                "#{input.id}/#{name}: children listing " \
+                                "differs from the reference: " \
+                                "#{got_children.inspect} vs " \
+                                "#{expected_children.inspect}"
+      end
+    end
+  end
+
+  it "answers element text like the reference" do
+    InputTaxonomy.well_formed.each do |input|
+      expected = Moxml::Reference.element_access_rows(reference_for(input))
+        .map { |(name, text, _content)| [name, text] }
+      adapters.each do |name|
+        doc = adapter_document(name, input.xml)
+        next unless doc
+        next if exempt?(input, :text, name)
+
+        got = elements(doc).map { |element| [element.name, element.text] }
+        expect(got).to eq(expected),
+                       "#{input.id}/#{name}: text face differs from the " \
+                       "reference: #{got.inspect} vs #{expected.inspect}"
+      end
+    end
+  end
+
+  it "answers attribute pairs like the reference" do
+    InputTaxonomy.well_formed.each do |input|
+      expected = reference_elements(reference_for(input)).map(&:attribute_pairs)
+      adapters.each do |name|
+        doc = adapter_document(name, input.xml)
+        next unless doc
+
+        got = elements(doc).map do |element|
+          element.attribute_pairs.map { |(key, value)| [key, value] }
+        end
+        expect(got).to eq(expected),
+                       "#{input.id}/#{name}: attribute face differs from " \
+                       "the reference: #{got.inspect} vs #{expected.inspect}"
+      end
+    end
+  end
+
+  it "answers PI and comment data like the reference" do
+    InputTaxonomy.well_formed.each do |input|
+      ref = reference_for(input)
+      expected_pis = Moxml::Reference.processing_instructions(ref)
+      expected_comments = Moxml::Reference.comments(ref)
+      adapters.each do |name|
+        doc = adapter_document(name, input.xml)
+        next unless doc
+
+        got_pis = pi_rows(doc)
+        expect(got_pis.map(&:first)).to eq(expected_pis.map(&:first)),
+                                        "#{input.id}/#{name}: PI targets " \
+                                        "differ from the reference"
+        unless exempt?(input, :pi_content, name)
+          expect(got_pis).to eq(expected_pis),
+                             "#{input.id}/#{name}: PI data differs " \
+                             "from the reference"
+        end
+        unless exempt?(input, :comment_content, name)
+          expect(comment_rows(doc)).to eq(expected_comments),
+                                       "#{input.id}/#{name}: comment data " \
+                                       "differs from the reference"
+        end
+      end
+    end
+  end
+
+  it "serializes to XML that re-parses to the reference information set" do
+    InputTaxonomy.well_formed.each do |input|
+      ref = reference_for(input)
+      expected_order = Moxml::Reference.element_names(ref)
+      expected_children = Moxml::Reference.child_element_names(ref)
+      expected_text = Moxml::Reference.element_access_rows(ref)
+        .map { |(name, text, _content)| [name, compact(text)] }
+      adapters.each do |name|
+        doc = adapter_document(name, input.xml)
+        next unless doc
+        next if exempt?(input, :serialize, name)
+
+        begin
+          serialized = doc.to_xml(indent: 0)
+        rescue Moxml::Error, NotImplementedError, LoadError
+          next # named engine limit, pinned by its own spec
+        end
+        reparsed = begin
+          Moxml::Reference.parse(serialized)
+        rescue Moxml::ParseError => e
+          raise Moxml::ParseError,
+                "#{input.id}/#{name}: serialized XML is not well-formed: " \
+                "#{e.message}"
+        end
+
+        expect(Moxml::Reference.element_names(reparsed)).to eq(expected_order),
+                                                            "#{input.id}/#{name}: serialized tree lost or reordered elements"
+        expect(Moxml::Reference.child_element_names(reparsed)).to eq(expected_children),
+                                                                  "#{input.id}/#{name}: serialized tree changed nesting"
+        got_text = Moxml::Reference.element_access_rows(reparsed)
+          .map { |(element, text, _content)| [element, compact(text)] }
+        expect(got_text).to eq(expected_text),
+                            "#{input.id}/#{name}: serialized tree changed " \
+                            "text: #{got_text.inspect} vs #{expected_text.inspect}"
+      end
+    end
+  end
+end