moxml 0.1.9 → 0.1.11

data/spec/fixtures/w3c/namespaces/1.0/rmt-ns10.xml

@@ -0,0 +1,156 @@
+<TESTCASES PROFILE="Richard Tobin's XML Namespaces 1.0 test suite 14 Feb 2003">
+
+<TEST RECOMMENDATION="NS1.0" SECTIONS="2" URI="001.xml" ID="rmt-ns10-001" TYPE="valid">
+Namespace name test: a perfectly good http URI
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="2" URI="002.xml" ID="rmt-ns10-002" TYPE="valid">
+Namespace name test: a syntactically plausible URI with a
+fictitious scheme
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="2" URI="003.xml" ID="rmt-ns10-003" TYPE="valid">
+Namespace name test: a perfectly good http URI with a fragment
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="2" URI="004.xml" ID="rmt-ns10-004" TYPE="error">
+Namespace name test: a relative URI (deprecated)
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="2" URI="005.xml" ID="rmt-ns10-005" TYPE="error">
+Namespace name test: a same-document relative URI (deprecated)
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="2" URI="006.xml" ID="rmt-ns10-006" TYPE="error">
+Namespace name test: an http IRI that is not a URI
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="1" URI="007.xml" ID="rmt-ns10-007" TYPE="valid">
+Namespace inequality test: different capitalization
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="1" URI="008.xml" ID="rmt-ns10-008" TYPE="valid">
+Namespace inequality test: different escaping
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="1" URI="009.xml" ID="rmt-ns10-009" TYPE="not-wf">
+Namespace equality test: plain repetition
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="1" URI="010.xml" ID="rmt-ns10-010" TYPE="not-wf">
+Namespace equality test: use of character reference
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="1" URI="011.xml" ID="rmt-ns10-011" TYPE="not-wf">
+Namespace equality test: use of entity reference
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="1" URI="012.xml" ID="rmt-ns10-012" TYPE="not-wf">
+Namespace inequality test: equal after attribute value normalization
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="3" URI="013.xml" ID="rmt-ns10-013" TYPE="not-wf">
+Bad QName syntax: multiple colons
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="3" URI="014.xml" ID="rmt-ns10-014" TYPE="not-wf">
+Bad QName syntax: colon at end
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="3" URI="015.xml" ID="rmt-ns10-015" TYPE="not-wf">
+Bad QName syntax: colon at start
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="2" URI="016.xml" ID="rmt-ns10-016" TYPE="not-wf">
+Bad QName syntax: xmlns:
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="-" URI="017.xml" ID="rmt-ns10-017" TYPE="invalid">
+Simple legal case: no namespaces
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="5.2" URI="018.xml" ID="rmt-ns10-018" TYPE="invalid">
+Simple legal case: default namespace
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="4" URI="019.xml" ID="rmt-ns10-019" TYPE="invalid">
+Simple legal case: prefixed element
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="4" URI="020.xml" ID="rmt-ns10-020" TYPE="invalid">
+Simple legal case: prefixed attribute
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="5.2" URI="021.xml" ID="rmt-ns10-021" TYPE="invalid">
+Simple legal case: default namespace and unbinding
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="5.2" URI="022.xml" ID="rmt-ns10-022" TYPE="invalid">
+Simple legal case: default namespace and rebinding
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="2" URI="023.xml" ID="rmt-ns10-023" TYPE="not-wf">
+Illegal use of 1.1-style prefix unbinding in 1.0 document
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="5.1" URI="024.xml" ID="rmt-ns10-024" TYPE="invalid">
+Simple legal case: prefix rebinding
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="4" URI="025.xml" ID="rmt-ns10-025" TYPE="not-wf">
+Unbound element prefix
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="4" URI="026.xml" ID="rmt-ns10-026" TYPE="not-wf">
+Unbound attribute prefix
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="2" URI="027.xml" ID="rmt-ns10-027" TYPE="invalid">
+Reserved prefixes and namespaces: using the xml prefix undeclared
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE05" URI="028.xml" ID="rmt-ns10-028" TYPE="invalid">
+Reserved prefixes and namespaces: declaring the xml prefix correctly
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE05" URI="029.xml" ID="rmt-ns10-029" TYPE="not-wf">
+Reserved prefixes and namespaces: declaring the xml prefix incorrectly
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE05" URI="030.xml" ID="rmt-ns10-030" TYPE="not-wf">
+Reserved prefixes and namespaces: binding another prefix
+to the xml namespace
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE05" URI="031.xml" ID="rmt-ns10-031" TYPE="not-wf">
+Reserved prefixes and namespaces: declaring the xmlns prefix
+with its correct URI (illegal)
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE05" URI="032.xml" ID="rmt-ns10-032" TYPE="not-wf">
+Reserved prefixes and namespaces: declaring the xmlns prefix
+with an incorrect URI
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE05" URI="033.xml" ID="rmt-ns10-033" TYPE="not-wf">
+Reserved prefixes and namespaces: binding another prefix
+to the xmlns namespace
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE05" URI="034.xml" ID="rmt-ns10-034" TYPE="invalid">
+Reserved prefixes and namespaces: binding a reserved prefix
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="5.3" URI="035.xml" ID="rmt-ns10-035" TYPE="not-wf">
+Attribute uniqueness: repeated identical attribute
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="5.3" URI="036.xml" ID="rmt-ns10-036" TYPE="not-wf">
+Attribute uniqueness: repeated attribute with different prefixes
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="5.3" URI="037.xml" ID="rmt-ns10-037" TYPE="invalid">
+Attribute uniqueness: different attributes with same local name
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="5.3" URI="038.xml" ID="rmt-ns10-038" TYPE="invalid">
+Attribute uniqueness: prefixed and unprefixed attributes with same
+local name
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="5.3" URI="039.xml" ID="rmt-ns10-039" TYPE="invalid">
+Attribute uniqueness: prefixed and unprefixed attributes with same
+local name, with default namespace
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="5.3" URI="040.xml" ID="rmt-ns10-040" TYPE="invalid">
+Attribute uniqueness: prefixed and unprefixed attributes with same
+local name, with default namespace and element in default namespace
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="5.3" URI="041.xml" ID="rmt-ns10-041" TYPE="invalid">
+Attribute uniqueness: prefixed and unprefixed attributes with same
+local name, element in same namespace as prefixed attribute
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE08" URI="042.xml" ID="rmt-ns10-042" TYPE="not-wf">
+Colon in PI name
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE08" URI="043.xml" ID="rmt-ns10-043" TYPE="not-wf">
+Colon in entity name
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE08" URI="044.xml" ID="rmt-ns10-044" TYPE="not-wf">
+Colon in entity name
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE08" URI="045.xml" ID="rmt-ns10-045" TYPE="invalid">
+Colon in ID attribute name
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE08" URI="046.xml" ID="rmt-ns10-046" TYPE="invalid">
+Colon in ID attribute name
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE03" URI="047.xml" ID="ht-ns10-047" TYPE="valid">
+Reserved name: _not_ an error
+</TEST>
+<TEST RECOMMENDATION="NS1.0" SECTIONS="NE03" URI="048.xml" ID="ht-ns10-048" TYPE="valid">
+Reserved name: _not_ an error
+</TEST>
+</TESTCASES>

data/spec/integration/shared_examples/node_wrappers/namespace_behavior.rb

@@ -24,10 +24,22 @@ RSpec.shared_examples "Moxml::Namespace" do
         expect(ns.uri).to eq("http://example.org")
       end
 
-      it "validates URI" do
+      it "validates URI per RFC 3986" do
         expect do
           element.add_namespace("xs", "invalid uri")
-        end.to raise_error(Moxml::NamespaceError, "Invalid URI: invalid uri")
+        end.to raise_error(Moxml::NamespaceError, /Invalid URI/)
+      end
+
+      it "accepts valid relative URI-references" do
+        expect do
+          element.add_namespace("xs", "my-custom-ns")
+        end.not_to raise_error
+      end
+
+      it "rejects empty URI for prefixed namespace declarations" do
+        expect do
+          element.add_namespace("xs", "")
+        end.to raise_error(Moxml::NamespaceError, /empty URI/)
       end
     end
 

data/spec/integration/shared_examples/w3c_namespace_examples.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "W3C namespace test: should parse" do |label, fixture_file, adapter, test_id|
+  it label do
+    skip "known #{adapter} limitation" if skip_for_adapter?(test_id, adapter)
+
+    xml = File.binread(File.join(W3C_NS_FIXTURES_DIR, fixture_file))
+    expect { moxml_context.parse(xml) }.not_to raise_error
+  end
+end

data/spec/integration/w3c_namespace_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# W3C XML Namespaces 1.0 Test Suite
+# Source: https://www.w3.org/XML/Test/ (xmlts20130923)
+# Tests from: xmlconf/eduni/namespaces/1.0/
+#
+# Test types per W3C:
+#   valid    - must be accepted without errors
+#   error    - namespace constraint violation; processors MAY report
+#   not-wf   - namespace well-formedness violation; must be rejected
+#   invalid  - validity error; non-validating parsers should accept
+
+RSpec.describe "W3C XML Namespaces 1.0 test suite" do
+  Moxml::Adapter::AVALIABLE_ADAPTERS.each do |adapter_name|
+    context "with #{adapter_name}" do
+      around do |example|
+        Moxml.with_config(adapter_name) do
+          example.run
+        end
+      end
+
+      let(:moxml_context) { Moxml.new }
+
+      W3C_NAMESPACE_TESTS.each do |test|
+        next unless File.exist?(File.join(W3C_NS_FIXTURES_DIR, test[:uri]))
+
+        test_label = "#{test[:id]}: #{test[:description]}"
+
+        case test[:type]
+        when "valid"
+          it_behaves_like "W3C namespace test: should parse",
+                          "#{test_label} [valid]", test[:uri], adapter_name, test[:id]
+
+        when "error"
+          # Namespace errors are advisory — processors MAY report them.
+          # We accept these documents (e.g. relative URIs are valid URI-references).
+          it_behaves_like "W3C namespace test: should parse",
+                          "#{test_label} [error - accepted]", test[:uri], adapter_name, test[:id]
+
+        when "not-wf"
+          # Namespace well-formedness violations should be caught by the parser,
+          # but enforcement varies significantly by adapter. These tests document
+          # adapter behavior and are not directly related to URI validation.
+          it "#{test_label} [not-wf]" do
+            xml = File.binread(File.join(W3C_NS_FIXTURES_DIR, test[:uri]))
+            raised = false
+            begin
+              moxml_context.parse(xml, strict: true)
+            rescue StandardError
+              raised = true
+            end
+
+            if raised
+              # Good: adapter correctly rejects namespace-ill-formed document
+            else
+              skip "#{adapter_name} does not enforce this namespace well-formedness rule"
+            end
+          end
+
+        when "invalid"
+          # Validity errors are for validating parsers. Non-validating parsers
+          # (which moxml wraps) should accept these documents.
+          it_behaves_like "W3C namespace test: should parse",
+                          "#{test_label} [invalid - accepted]", test[:uri], adapter_name, test[:id]
+        end
+      end
+    end
+  end
+end

data/spec/moxml/adapter/libxml_spec.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
-require "libxml"
+begin
+  require "libxml"
+rescue LoadError
+  # LibXML gem not available - skip all specs in this file
+  return
+end
+
 require "moxml/adapter/libxml"
 
 RSpec.describe Moxml::Adapter::Libxml do

data/spec/moxml/adapter/oga_spec.rb

@@ -11,4 +11,96 @@ RSpec.describe Moxml::Adapter::Oga do
   end
 
   it_behaves_like "xml adapter"
+
+  describe "entity handling" do
+    it "preserves non-breaking space through parse and serialize round-trip" do
+      xml = "<root>Item&nbsp;One</root>"
+      doc = described_class.parse(xml)
+      serialized = doc.to_xml
+      # After round-trip, the entity reference should be preserved
+      expect(serialized).to include("&nbsp;")
+      expect(serialized).to include("Item")
+      expect(serialized).to include("One")
+    end
+
+    it "correctly parses numeric character references" do
+      xml = "<root>&#160;</root>"
+      doc = described_class.parse(xml)
+      text = described_class.text_content(doc.at_xpath("//root"))
+
+      # Should contain the actual non-breaking space character (U+00A0)
+      expect(text.bytes).to include(160)
+    end
+
+    it "handles multiple different entities" do
+      xml = "<root>&nbsp;&mdash;&lsquo;</root>"
+      doc = described_class.parse(xml)
+      serialized = doc.to_xml
+
+      # All entities should be preserved in round-trip
+      expect(serialized).to include("&nbsp;")
+      expect(serialized).to include("&mdash;")
+      expect(serialized).to include("&lsquo;")
+    end
+
+    it "preserves entities when creating text nodes programmatically" do
+      context = Moxml::Context.new(:oga)
+      doc = context.create_document
+      root = doc.create_element("root")
+      doc.add_child(root)
+      text = doc.create_text("Hello&nbsp;World")
+      root.add_child(text)
+
+      serialized = doc.to_xml
+      expect(serialized).to include("Hello&nbsp;World")
+    end
+
+    it "preserves entities when setting text content programmatically" do
+      context = Moxml::Context.new(:oga)
+      doc = context.create_document
+      root = doc.create_element("root")
+      doc.add_child(root)
+      text = doc.create_text("placeholder")
+      root.add_child(text)
+      text.content = "Value&nbsp;Here"
+
+      serialized = doc.to_xml
+      expect(serialized).to include("Value&nbsp;Here")
+    end
+
+    it "preserves entities in attribute values through parse round-trip" do
+      xml = '<root attr="one&nbsp;two"/>'
+      doc = described_class.parse(xml)
+      root_native = doc.at_xpath("//root")
+      value = described_class.get_attribute_value(root_native, "attr")
+
+      expect(value).to eq("one&nbsp;two")
+    end
+
+    it "preserves entities when setting attribute values programmatically" do
+      context = Moxml::Context.new(:oga)
+      doc = context.create_document
+      root = doc.create_element("root")
+      doc.add_child(root)
+      root["data"] = "a&nbsp;b"
+
+      serialized = doc.to_xml
+      expect(serialized).to include('data="a&nbsp;b"')
+    end
+
+    it "does not marker-encode unknown entities in programmatic text" do
+      # Unknown entities (not in W3C registry) are left as-is by encode_entity_markers.
+      # Oga will drop them during serialization since they're not valid XML entities.
+      context = Moxml::Context.new(:oga)
+      doc = context.create_document
+      root = doc.create_element("root")
+      doc.add_child(root)
+      text = doc.create_text("test&foo;bar")
+      root.add_child(text)
+
+      serialized = doc.to_xml
+      # &foo; is not a known entity, so it won't survive Oga's serialization
+      expect(serialized).not_to include("\x01")
+    end
+  end
 end

data/spec/moxml/config_spec.rb

@@ -12,6 +12,81 @@ RSpec.describe Moxml::Config do
       expect(config.default_indent).to eq(2)
       expect(config.entity_encoding).to eq(:basic)
     end
+
+    it "sets default entity_load_mode to :required" do
+      expect(config.entity_load_mode).to eq(:required)
+    end
+
+    it "sets default namespace_uri_mode to :strict" do
+      expect(config.namespace_uri_mode).to eq(:strict)
+    end
+  end
+
+  describe "#entity_load_mode=" do
+    it "accepts valid modes" do
+      %i[required optional disabled custom].each do |mode|
+        config.entity_load_mode = mode
+        expect(config.entity_load_mode).to eq(mode)
+      end
+    end
+
+    it "raises error for invalid mode" do
+      expect do
+        config.entity_load_mode = :invalid
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#load_external_entities=" do
+    it "maps true to :required" do
+      config.load_external_entities = true
+      expect(config.entity_load_mode).to eq(:required)
+    end
+
+    it "maps false to :disabled" do
+      config.load_external_entities = false
+      expect(config.entity_load_mode).to eq(:disabled)
+    end
+
+    it "accepts symbol values" do
+      config.load_external_entities = :optional
+      expect(config.entity_load_mode).to eq(:optional)
+    end
+  end
+
+  describe "#load_external_entities" do
+    it "returns true when mode is :required" do
+      config.entity_load_mode = :required
+      expect(config.load_external_entities).to be true
+    end
+
+    it "returns false when mode is not :required" do
+      config.entity_load_mode = :disabled
+      expect(config.load_external_entities).to be false
+    end
+  end
+
+  describe "#namespace_uri_mode=" do
+    it "accepts :strict" do
+      config.namespace_uri_mode = :strict
+      expect(config.namespace_uri_mode).to eq(:strict)
+    end
+
+    it "accepts :lenient" do
+      config.namespace_uri_mode = :lenient
+      expect(config.namespace_uri_mode).to eq(:lenient)
+    end
+
+    it "accepts string values" do
+      config.namespace_uri_mode = "lenient"
+      expect(config.namespace_uri_mode).to eq(:lenient)
+    end
+
+    it "raises error for invalid mode" do
+      expect do
+        config.namespace_uri_mode = :invalid
+      end.to raise_error(ArgumentError, /Invalid namespace_uri_mode/)
+    end
   end
 
   describe "#adapter=" do

data/spec/moxml/doctype_spec.rb

@@ -8,7 +8,6 @@ RSpec.describe Moxml::Doctype do
 
   describe "#name" do
     it "returns doctype name" do
-      skip "Doctype accessor methods not yet implemented in all adapters"
       doctype = doc.create_doctype("root", nil, "test.dtd")
       expect(doctype.name).to eq("root")
     end
@@ -16,15 +15,32 @@ RSpec.describe Moxml::Doctype do
 
   describe "#system_id" do
     it "returns system identifier" do
-      skip "Doctype accessor methods not yet implemented in all adapters"
       doctype = doc.create_doctype("root", nil, "test.dtd")
       expect(doctype.system_id).to eq("test.dtd")
     end
   end
 
+  describe "#external_id" do
+    it "returns external identifier when present" do
+      doctype = doc.create_doctype("html", "-//W3C//DTD HTML 4.01//EN", "http://www.w3.org/TR/html4/strict.dtd")
+      expect(doctype.external_id).to eq("-//W3C//DTD HTML 4.01//EN")
+    end
+
+    it "returns nil when not present" do
+      doctype = doc.create_doctype("root", nil, "test.dtd")
+      expect(doctype.external_id).to be_nil
+    end
+  end
+
+  describe "#identifier" do
+    it "returns the doctype name" do
+      doctype = doc.create_doctype("html", nil, nil)
+      expect(doctype.identifier).to eq("html")
+    end
+  end
+
   describe "creation" do
     it "creates a doctype" do
-      skip "Doctype accessor methods not yet implemented in all adapters"
       doctype = doc.create_doctype("html", nil, nil)
       expect(doctype).to be_a(described_class)
       expect(doctype.name).to eq("html")

data/spec/moxml/entity_registry_spec.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+RSpec.describe Moxml::EntityRegistry do
+  before do
+    described_class.reset
+  end
+
+  describe ".entity_data" do
+    it "loads entity data from bundled JSON" do
+      data = described_class.entity_data
+      expect(data).to be_a(Hash)
+      expect(data.keys).to include("amp", "nbsp", "copy")
+    end
+
+    it "caches entity data" do
+      data1 = described_class.entity_data
+      data2 = described_class.entity_data
+      expect(data1.object_id).to eq(data2.object_id)
+    end
+  end
+
+  describe ".reset" do
+    it "clears cached entity data" do
+      data1 = described_class.entity_data
+      described_class.reset
+      # After reset, a new data hash is loaded
+      expect(described_class.entity_data).not_to be(data1)
+    end
+  end
+
+  describe "#initialize with :required mode" do
+    it "loads all entities from bundled data" do
+      registry = described_class.new(mode: :required)
+      expect(registry.by_name.keys.length).to be > 2000
+      expect(registry.declared?("nbsp")).to be true
+      expect(registry.declared?("amp")).to be true
+    end
+
+    it "raises error if entity data unavailable" do
+      allow(described_class).to receive(:entity_data).and_return(nil)
+      expect do
+        described_class.new(mode: :required)
+      end.to raise_error(Moxml::EntityRegistry::EntityDataError)
+    end
+  end
+
+  describe "#initialize with :disabled mode" do
+    it "creates empty registry" do
+      registry = described_class.new(mode: :disabled)
+      expect(registry.by_name.keys).to be_empty
+      expect(registry.declared?("nbsp")).to be false
+    end
+  end
+
+  describe "#initialize with :optional mode" do
+    it "loads entities when available" do
+      registry = described_class.new(mode: :optional)
+      expect(registry.by_name.keys.length).to be > 2000
+      expect(registry.declared?("nbsp")).to be true
+    end
+
+    it "does not raise when entity data unavailable" do
+      allow(described_class).to receive(:entity_data).and_return(nil)
+      expect do
+        described_class.new(mode: :optional)
+      end.not_to raise_error
+    end
+  end
+
+  describe "#initialize with :custom mode" do
+    it "loads custom entities from provider" do
+      custom_provider = -> { { "custom" => 12345, "special" => 67890 } }
+      registry = described_class.new(mode: :custom,
+                                     entity_provider: custom_provider)
+      expect(registry.by_name.keys).to contain_exactly("custom", "special")
+      expect(registry.declared?("custom")).to be true
+      expect(registry.codepoint_for_name("custom")).to eq(12345)
+    end
+
+    it "works with nil provider" do
+      registry = described_class.new(mode: :custom, entity_provider: nil)
+      expect(registry.by_name.keys).to be_empty
+    end
+
+    it "works with provider returning nil" do
+      registry = described_class.new(mode: :custom, entity_provider: -> {})
+      expect(registry.by_name.keys).to be_empty
+    end
+  end
+
+  describe "#declared?" do
+    it "returns true for known entities" do
+      registry = described_class.new
+      expect(registry.declared?("nbsp")).to be true
+      expect(registry.declared?("amp")).to be true
+      expect(registry.declared?("copy")).to be true
+    end
+
+    it "returns false for unknown entities" do
+      registry = described_class.new
+      expect(registry.declared?("unknown_entity")).to be false
+    end
+  end
+
+  describe "#codepoint_for_name" do
+    it "returns Unicode codepoint for entity name" do
+      registry = described_class.new
+      expect(registry.codepoint_for_name("nbsp")).to eq(160)
+      expect(registry.codepoint_for_name("amp")).to eq(38)
+      expect(registry.codepoint_for_name("copy")).to eq(169)
+    end
+
+    it "returns nil for unknown entity" do
+      registry = described_class.new
+      expect(registry.codepoint_for_name("unknown")).to be_nil
+    end
+  end
+
+  describe "#names_for_codepoint" do
+    it "returns all entity names for a codepoint" do
+      registry = described_class.new
+      # nbsp has codepoint 160
+      names = registry.names_for_codepoint(160)
+      expect(names).to be_an(Array)
+      expect(names).to include("nbsp")
+    end
+  end
+
+  describe "#primary_name_for_codepoint" do
+    it "returns first entity name for codepoint" do
+      registry = described_class.new
+      name = registry.primary_name_for_codepoint(160)
+      expect(name).to be_a(String)
+    end
+  end
+
+  describe "#register" do
+    it "adds entities to the registry" do
+      registry = described_class.new(mode: :disabled)
+      registry.register({ "new_entity" => 99999 })
+      expect(registry.declared?("new_entity")).to be true
+      expect(registry.codepoint_for_name("new_entity")).to eq(99999)
+    end
+
+    it "allows multiple names for same codepoint" do
+      registry = described_class.new(mode: :disabled)
+      registry.register({ "entity_a" => 12345, "entity_b" => 12345 })
+      expect(registry.names_for_codepoint(12345)).to contain_exactly(
+        "entity_a", "entity_b"
+      )
+    end
+  end
+
+  describe "#clear!" do
+    it "removes all entities" do
+      registry = described_class.new
+      expect(registry.by_name.keys).not_to be_empty
+      registry.clear!
+      expect(registry.by_name.keys).to be_empty
+    end
+  end
+
+  describe "load_html5, load_mathml, load_iso, load_all" do
+    it "load_html5 returns self for chaining" do
+      registry = described_class.new
+      expect(registry.load_html5).to be(registry)
+    end
+
+    it "load_mathml returns self for chaining" do
+      registry = described_class.new
+      expect(registry.load_mathml).to be(registry)
+    end
+
+    it "load_iso returns self for chaining" do
+      registry = described_class.new
+      expect(registry.load_iso).to be(registry)
+    end
+
+    it "load_all returns self for chaining" do
+      registry = described_class.new
+      expect(registry.load_all).to be(registry)
+    end
+  end
+end