lutaml-model 0.3.28 → 0.3.30

data/spec/lutaml/model/xml_mapping_spec.rb

@@ -1,4 +1,8 @@
 require "spec_helper"
+
+require "lutaml/model/xml_adapter/ox_adapter"
+require "lutaml/model/xml_adapter/oga_adapter"
+
 require_relative "../../../lib/lutaml/model/xml_mapping"
 require_relative "../../../lib/lutaml/model/xml_mapping_rule"
 
@@ -177,8 +181,28 @@ module XmlMapping
     end
   end
 
+  class MapAllWithCustomMethod < Lutaml::Model::Serializable
+    attribute :all_content, :string
+
+    xml do
+      root "MapAllWithCustomMethod"
+
+      map_all to: :all_content, with: { to: :content_to_xml, from: :content_from_xml }
+    end
+
+    def content_to_xml(model, parent, doc)
+      content = model.all_content.sub(/^<div>/, "").sub(/<\/div>$/, "")
+      doc.add_xml_fragment(parent, content)
+    end
+
+    def content_from_xml(model, value)
+      model.all_content = "<div>#{value}</div>"
+    end
+  end
+
   class WithMapAll < Lutaml::Model::Serializable
     attribute :all_content, :string
+    attribute :attr, :string
 
     xml do
       root "WithMapAll"
@@ -258,674 +282,791 @@ module XmlMapping
 end
 
 RSpec.describe Lutaml::Model::XmlMapping do
-  let(:mapping) { described_class.new }
+  shared_examples "having XML Mappings" do |adapter_class|
+    around do |example|
+      old_adapter = Lutaml::Model::Config.xml_adapter
+      Lutaml::Model::Config.xml_adapter = adapter_class
 
-  context "attribute namespace" do
-    input_xml = '<ns1:example ex1:alpha="hello" beta="bye" xmlns:ns1="http://www.check.com" xmlns:ex1="http://www.example.com"></ns1:example>'
-
-    it "checks the attribute with and without namespace" do
-      parsed = XmlMapping::AttributeNamespace.from_xml(input_xml)
-      expect(parsed.alpha).to eq("hello")
-      expect(parsed.beta).to eq("bye")
-      expect(parsed.to_xml).to be_equivalent_to(input_xml)
+      example.run
+    ensure
+      Lutaml::Model::Config.xml_adapter = old_adapter
     end
-  end
 
-  context "explicit namespace" do
-    mml = '<math xmlns="http://www.w3.org/1998/Math/MathML"><mfenced open="("></mfenced></math>'
+    let(:mapping) { Lutaml::Model::XmlMapping.new }
 
-    it "nil namespace" do
-      parsed = XmlMapping::MmlMath.from_xml(mml)
-      expect(parsed.to_xml).to be_equivalent_to(mml)
-    end
-  end
-
-  context "overriding child namespace prefix" do
-    let(:input_xml) do
-      <<~XML
-        <OverrideDefaultNamespacePrefix xmlns:abc="http://www.omg.org/spec/XMI/20131001" xmlns:GML="http://www.sparxsystems.com/profiles/GML/1.0" xmlns:CityGML="http://www.sparxsystems.com/profiles/CityGML/1.0">
-          <abc:SameElementName App="hello">
-            <GML:ApplicationSchema>GML App</GML:ApplicationSchema>
-            <CityGML:ApplicationSchema>CityGML App</CityGML:ApplicationSchema>
-            <abc:ApplicationSchema>App</abc:ApplicationSchema>
-          </abc:SameElementName>
-        </OverrideDefaultNamespacePrefix>
+    context "attribute namespace" do
+      input_xml = <<~XML
+        <ns1:example ex1:alpha="hello"
+                     beta="bye"
+                     xmlns:ns1="http://www.check.com"
+                     xmlns:ex1="http://www.example.com">
+        </ns1:example>
       XML
-    end
-
-    it "expect to round-trips" do
-      parsed = XmlMapping::OverrideDefaultNamespacePrefix.from_xml(input_xml)
-      expect(parsed.to_xml).to be_equivalent_to(input_xml)
-    end
-  end
 
-  context "with same name elements" do
-    let(:input_xml) do
-      <<~XML
-        <SameElementName App="hello" xmlns="http://www.omg.org/spec/XMI/20131001" xmlns:GML="http://www.sparxsystems.com/profiles/GML/1.0" xmlns:CityGML="http://www.sparxsystems.com/profiles/CityGML/1.0">
-          <GML:ApplicationSchema>GML App</GML:ApplicationSchema>
-          <CityGML:ApplicationSchema>CityGML App</CityGML:ApplicationSchema>
-          <ApplicationSchema>App</ApplicationSchema>
-        </SameElementName>
-      XML
-    end
-
-    it "parses XML and serializes elements with the same name" do
-      parsed = XmlMapping::SameNameDifferentNamespace.from_xml(input_xml)
-
-      expect(parsed.citygml_application_schema).to eq("CityGML App")
-      expect(parsed.gml_application_schema).to eq("GML App")
-      expect(parsed.application_schema).to eq("App")
-      expect(parsed.app).to eq("hello")
-      expect(parsed.element_order).to eq(["text", "ApplicationSchema", "text",
-                                          "ApplicationSchema", "text", "ApplicationSchema", "text"])
-      expect(XmlMapping::SameNameDifferentNamespace.from_xml(input_xml).to_xml).to be_equivalent_to(input_xml)
-    end
-  end
-
-  context "with elements have different prefixed namespaces" do
-    before do
-      mapping.root("XMI")
-      mapping.namespace("http://www.omg.org/spec/XMI/20131001")
-      mapping.map_element(
-        "ApplicationSchema",
-        to: :gml_application_schema,
-        namespace: "http://www.sparxsystems.com/profiles/GML/1.0",
-        prefix: "GML",
-      )
-      mapping.map_element(
-        "ApplicationSchema",
-        to: :citygml_application_schema,
-        namespace: "http://www.sparxsystems.com/profiles/CityGML/1.0",
-        prefix: "CityGML",
-      )
-      mapping.map_element(
-        "ApplicationSchema",
-        to: :citygml_application_schema,
-        namespace: "http://www.sparxsystems.com/profiles/CGML/1.0",
-        prefix: "CGML",
-      )
-    end
-
-    it "maps elements correctly" do
-      expect(mapping.elements[0].namespace).to eq("http://www.sparxsystems.com/profiles/GML/1.0")
-      expect(mapping.elements[1].namespace).to eq("http://www.sparxsystems.com/profiles/CityGML/1.0")
-      expect(mapping.elements[2].namespace).to eq("http://www.sparxsystems.com/profiles/CGML/1.0")
-      expect(mapping.elements.size).to eq(3)
+      it "checks the attribute with and without namespace" do
+        parsed = XmlMapping::AttributeNamespace.from_xml(input_xml)
+        expect(parsed.alpha).to eq("hello")
+        expect(parsed.beta).to eq("bye")
+        expect(parsed.to_xml).to be_equivalent_to(input_xml)
+      end
     end
-  end
 
-  context "with child having explicit namespaces" do
-    let(:xml) do
-      <<~XML.strip
-        <pn:WithChildExplicitNamespaceNil xmlns:pn="http://parent-namespace" xmlns:cn="http://child-namespace">
-          <pn:DefaultNamespace>default namespace text</pn:DefaultNamespace>
-          <cn:WithNamespace>explicit namespace text</cn:WithNamespace>
-          <WithoutNamespace>without namespace text</WithoutNamespace>
-        </pn:WithChildExplicitNamespaceNil>
+    context "explicit namespace" do
+      mml = <<~XML
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+          <mfenced open="("></mfenced>
+        </math>
       XML
-    end
-
-    let(:parsed) do
-      XmlMapping::WithChildExplicitNamespace.from_xml(xml)
-    end
 
-    it "reads element with default namespace" do
-      expect(parsed.with_default_namespace).to eq("default namespace text")
-    end
-
-    it "reads element with explicit namespace" do
-      expect(parsed.with_namespace).to eq("explicit namespace text")
-    end
-
-    it "reads element without namespace" do
-      expect(parsed.without_namespace).to eq("without namespace text")
+      it "nil namespace" do
+        parsed = XmlMapping::MmlMath.from_xml(mml)
+        expect(parsed.to_xml).to be_equivalent_to(mml)
+      end
     end
 
-    it "round-trips xml with child explicit namespace" do
-      expect(parsed.to_xml).to be_equivalent_to(xml)
-    end
-  end
+    # Skipping for OX because it does not handle namespaces
+    context "overriding child namespace prefix", skip: adapter_class != Lutaml::Model::XmlAdapter::NokogiriAdapter do
+      let(:input_xml) do
+        <<~XML
+          <OverrideDefaultNamespacePrefix
+              xmlns:abc="http://www.omg.org/spec/XMI/20131001"
+              xmlns:GML="http://www.sparxsystems.com/profiles/GML/1.0"
+              xmlns:CityGML="http://www.sparxsystems.com/profiles/CityGML/1.0">
+
+            <abc:SameElementName App="hello">
+              <GML:ApplicationSchema>GML App</GML:ApplicationSchema>
+              <CityGML:ApplicationSchema>CityGML App</CityGML:ApplicationSchema>
+              <abc:ApplicationSchema>App</abc:ApplicationSchema>
+            </abc:SameElementName>
+          </OverrideDefaultNamespacePrefix>
+        XML
+      end
 
-  context "with default namespace" do
-    before do
-      mapping.root("ceramic")
-      mapping.namespace("https://example.com/ceramic/1.2")
-      mapping.map_element("type", to: :type)
-      mapping.map_element("color", to: :color, delegate: :glaze)
-      mapping.map_element("finish", to: :finish, delegate: :glaze)
+      it "expect to round-trips" do
+        parsed = XmlMapping::OverrideDefaultNamespacePrefix.from_xml(input_xml)
+        expect(parsed.to_xml).to be_equivalent_to(input_xml)
+      end
     end
 
-    it "sets the default namespace for the root element" do
-      expect(mapping.namespace_uri).to eq("https://example.com/ceramic/1.2")
-      expect(mapping.namespace_prefix).to be_nil
-    end
+    context "with same name elements" do
+      let(:input_xml) do
+        <<~XML
+          <SameElementName App="hello"
+              xmlns="http://www.omg.org/spec/XMI/20131001"
+              xmlns:GML="http://www.sparxsystems.com/profiles/GML/1.0"
+              xmlns:CityGML="http://www.sparxsystems.com/profiles/CityGML/1.0">
 
-    it "maps elements correctly" do
-      expect(mapping.elements.size).to eq(3)
-      expect(mapping.elements[0].name).to eq("type")
-      expect(mapping.elements[1].delegate).to eq(:glaze)
-    end
-  end
+            <GML:ApplicationSchema>GML App</GML:ApplicationSchema>
+            <CityGML:ApplicationSchema>CityGML App</CityGML:ApplicationSchema>
+            <ApplicationSchema>App</ApplicationSchema>
+          </SameElementName>
+        XML
+      end
 
-  context "with prefixed namespace" do
-    before do
-      mapping.root("ceramic")
-      mapping.namespace("https://example.com/ceramic/1.2", "cera")
-      mapping.map_element("type", to: :type)
-      mapping.map_element("color", to: :color, delegate: :glaze)
-      mapping.map_element("finish", to: :finish, delegate: :glaze)
-    end
+      let(:expected_order) do
+        {
+          Lutaml::Model::XmlAdapter::NokogiriAdapter => [
+            "text",
+            "ApplicationSchema",
+            "text",
+            "ApplicationSchema",
+            "text",
+            "ApplicationSchema",
+            "text",
+          ],
+          Lutaml::Model::XmlAdapter::OxAdapter => [
+            "ApplicationSchema",
+            "ApplicationSchema",
+            "ApplicationSchema",
+          ],
+        }
+      end
 
-    it "sets the namespace with prefix for the root element" do
-      expect(mapping.namespace_uri).to eq("https://example.com/ceramic/1.2")
-      expect(mapping.namespace_prefix).to eq("cera")
-    end
+      let(:parsed) { XmlMapping::SameNameDifferentNamespace.from_xml(input_xml) }
 
-    it "maps elements correctly" do
-      expect(mapping.elements.size).to eq(3)
-      expect(mapping.elements[0].name).to eq("type")
-      expect(mapping.elements[1].delegate).to eq(:glaze)
-    end
-  end
+      it "citygml_application_schema should be correct" do
+        expect(parsed.citygml_application_schema).to eq("CityGML App")
+      end
 
-  context "with element-level namespace" do
-    before do
-      mapping.root("ceramic")
-      mapping.map_element(
-        "type",
-        to: :type,
-        namespace: "https://example.com/ceramic/1.2",
-        prefix: "cera",
-      )
-      mapping.map_element("color", to: :color, delegate: :glaze)
-      mapping.map_element("finish", to: :finish, delegate: :glaze)
-    end
-
-    it "sets the namespace for individual elements" do
-      expect(mapping.elements.size).to eq(3)
-      expect(mapping.elements[0].namespace).to eq("https://example.com/ceramic/1.2")
-      expect(mapping.elements[0].prefix).to eq("cera")
-      expect(mapping.elements[1].delegate).to eq(:glaze)
-    end
-  end
+      it "gml_application_schema should be correct" do
+        expect(parsed.gml_application_schema).to eq("GML App")
+      end
 
-  context "with attribute-level namespace" do
-    before do
-      mapping.root("ceramic")
-      mapping.map_attribute(
-        "date",
-        to: :date,
-        namespace: "https://example.com/ceramic/1.2",
-        prefix: "cera",
-      )
-      mapping.map_element("type", to: :type)
-      mapping.map_element("color", to: :color, delegate: :glaze)
-      mapping.map_element("finish", to: :finish, delegate: :glaze)
-    end
-
-    it "sets the namespace for individual attributes" do
-      expect(mapping.attributes.size).to eq(1)
-      expect(mapping.attributes[0].namespace).to eq("https://example.com/ceramic/1.2")
-      expect(mapping.attributes[0].prefix).to eq("cera")
-    end
-  end
+      it "application_schema should be correct" do
+        expect(parsed.application_schema).to eq("App")
+      end
 
-  context "with nil element-level namespace" do
-    let(:expected_xml) do
-      <<~XML
-        <xmi:ChildNamespaceNil xmlns:xmi="http://www.omg.org/spec/XMI/20131001" xmlns:new="http://www.omg.org/spec/XMI/20161001">
-          <xmi:ElementDefaultNamespace>Default namespace</xmi:ElementDefaultNamespace>
-          <ElementNilNamespace>No namespace</ElementNilNamespace>
-          <new:ElementNewNamespace>New namespace</new:ElementNewNamespace>
-        </xmi:ChildNamespaceNil>
-      XML
-    end
+      it "app should be correct" do
+        expect(parsed.app).to eq("hello")
+      end
 
-    let(:model) do
-      XmlMapping::ChildNamespaceNil.new(
-        {
-          element_default_namespace: "Default namespace",
-          element_nil_namespace: "No namespace",
-          element_new_namespace: "New namespace",
-        },
-      )
-    end
+      it "element_order should be correct" do
+        expect(parsed.element_order).to eq(expected_order[adapter_class])
+      end
 
-    it "expect to apply correct namespaces" do
-      expect(model.to_xml).to be_equivalent_to(expected_xml)
+      it "to_xml should be correct" do
+        expect(parsed.to_xml).to be_equivalent_to(input_xml)
+      end
     end
-  end
 
-  context "with schemaLocation" do
-    context "when mixed: false" do
-      let(:xml) do
-        <<~XML
-          <p xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-             xsi:schemaLocation="http://www.opengis.net/gml/3.2 http://schemas.opengis.net/gml/3.2.1/gml.xsd">
-            <p xmlns:xsi="http://another-instance"
-               xsi:schemaLocation="http://www.opengis.net/gml/3.7">
-              Some text inside paragraph
-            </p>
-          </p>
-        XML
+    context "with elements have different prefixed namespaces" do
+      before do
+        mapping.root("XMI")
+        mapping.namespace("http://www.omg.org/spec/XMI/20131001")
+        mapping.map_element(
+          "ApplicationSchema",
+          to: :gml_application_schema,
+          namespace: "http://www.sparxsystems.com/profiles/GML/1.0",
+          prefix: "GML",
+        )
+        mapping.map_element(
+          "ApplicationSchema",
+          to: :citygml_application_schema,
+          namespace: "http://www.sparxsystems.com/profiles/CityGML/1.0",
+          prefix: "CityGML",
+        )
+        mapping.map_element(
+          "ApplicationSchema",
+          to: :citygml_application_schema,
+          namespace: "http://www.sparxsystems.com/profiles/CGML/1.0",
+          prefix: "CGML",
+        )
       end
 
-      it "contain schemaLocation attributes" do
-        expect(Paragraph.from_xml(xml).to_xml).to be_equivalent_to(xml)
+      it "maps elements correctly" do
+        expect(mapping.elements[0].namespace).to eq("http://www.sparxsystems.com/profiles/GML/1.0")
+        expect(mapping.elements[1].namespace).to eq("http://www.sparxsystems.com/profiles/CityGML/1.0")
+        expect(mapping.elements[2].namespace).to eq("http://www.sparxsystems.com/profiles/CGML/1.0")
+        expect(mapping.elements.size).to eq(3)
       end
     end
 
-    context "when mixed: true" do
+    context "with child having explicit namespaces" do
       let(:xml) do
-        <<~XML
-          <schemaLocationOrdered xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-             xsi:schemaLocation="http://www.opengis.net/gml/3.2 http://schemas.opengis.net/gml/3.2.1/gml.xsd">
-            <schemaLocationOrdered xmlns:xsi="http://another-instance"
-               xsi:schemaLocation="http://www.opengis.net/gml/3.7">
-              Some text inside paragraph
-            </schemaLocationOrdered>
-          </schemaLocationOrdered>
+        <<~XML.strip
+          <pn:WithChildExplicitNamespaceNil xmlns:pn="http://parent-namespace" xmlns:cn="http://child-namespace">
+            <pn:DefaultNamespace>default namespace text</pn:DefaultNamespace>
+            <cn:WithNamespace>explicit namespace text</cn:WithNamespace>
+            <WithoutNamespace>without namespace text</WithoutNamespace>
+          </pn:WithChildExplicitNamespaceNil>
         XML
       end
 
-      it "contain schemaLocation attributes" do
-        expect(XmlMapping::SchemaLocationOrdered.from_xml(xml).to_xml).to be_equivalent_to(xml)
+      let(:parsed) do
+        XmlMapping::WithChildExplicitNamespace.from_xml(xml)
       end
-    end
-  end
 
-  context "with multiple schemaLocations" do
-    let(:xml) do
-      <<~XML
-        <p xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-           xsi:schemaLocation="http://www.opengis.net/gml/3.2 http://schemas.opengis.net/gml/3.2.1/gml.xsd http://www.w3.org/1999/xlink http://www.w3.org/1999/xlink.xsd">
-          <p xmlns:xsi="http://another-instance"
-             xsi:schemaLocation="http://www.opengis.net/gml/3.7 http://schemas.opengis.net/gml/3.7.1/gml.xsd http://www.isotc211.org/2005/gmd http://schemas.opengis.net/iso/19139/20070417/gmd/gmd.xsd">
-            Some text inside paragraph
-          </p>
-        </p>
-      XML
-    end
-
-    it "parses and serializes multiple schemaLocation attributes" do
-      parsed = Paragraph.from_xml(xml)
-      expect(parsed.schema_location.size).to eq(2)
-      expect(parsed.schema_location[0].namespace).to eq("http://www.opengis.net/gml/3.2")
-      expect(parsed.schema_location[0].location).to eq("http://schemas.opengis.net/gml/3.2.1/gml.xsd")
-      expect(parsed.schema_location[1].namespace).to eq("http://www.w3.org/1999/xlink")
-      expect(parsed.schema_location[1].location).to eq("http://www.w3.org/1999/xlink.xsd")
-
-      serialized = parsed.to_xml
-      expect(serialized).to be_equivalent_to(xml)
-      expect(serialized).to include('xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"')
-      expect(serialized).to include('xsi:schemaLocation="http://www.opengis.net/gml/3.2 http://schemas.opengis.net/gml/3.2.1/gml.xsd http://www.w3.org/1999/xlink http://www.w3.org/1999/xlink.xsd"')
-    end
+      it "reads element with default namespace" do
+        expect(parsed.with_default_namespace).to eq("default namespace text")
+      end
 
-    it "handles nested elements with different schemaLocations" do
-      parsed = Paragraph.from_xml(xml)
-      nested_p = parsed.paragraph
+      it "reads element with explicit namespace" do
+        expect(parsed.with_namespace).to eq("explicit namespace text")
+      end
 
-      expect(nested_p).to be_a(Paragraph)
-      expect(nested_p.schema_location.size).to eq(2)
-      expect(nested_p.schema_location[0].namespace).to eq("http://www.opengis.net/gml/3.7")
-      expect(nested_p.schema_location[0].location).to eq("http://schemas.opengis.net/gml/3.7.1/gml.xsd")
-      expect(nested_p.schema_location[1].namespace).to eq("http://www.isotc211.org/2005/gmd")
-      expect(nested_p.schema_location[1].location).to eq("http://schemas.opengis.net/iso/19139/20070417/gmd/gmd.xsd")
+      it "reads element without namespace" do
+        expect(parsed.without_namespace).to eq("without namespace text")
+      end
 
-      serialized = parsed.to_xml
-      expect(serialized).to include('xmlns:xsi="http://another-instance"')
-      expect(serialized).to include('xsi:schemaLocation="http://www.opengis.net/gml/3.7 http://schemas.opengis.net/gml/3.7.1/gml.xsd http://www.isotc211.org/2005/gmd http://schemas.opengis.net/iso/19139/20070417/gmd/gmd.xsd"')
+      it "round-trips xml with child explicit namespace" do
+        expect(parsed.to_xml).to be_equivalent_to(xml)
+      end
     end
 
-    it "creates XML with multiple schemaLocations" do
-      paragraph = Paragraph.new(
-        schema_location: Lutaml::Model::SchemaLocation.new(
-          schema_location: {
-            "http://www.opengis.net/gml/3.2" => "http://schemas.opengis.net/gml/3.2.1/gml.xsd",
-            "http://www.w3.org/1999/xlink" => "http://www.w3.org/1999/xlink.xsd",
-          },
-          prefix: "xsi",
-        ),
-        paragraph: Paragraph.new(
-          schema_location: Lutaml::Model::SchemaLocation.new(
-            schema_location: {
-              "http://www.opengis.net/gml/3.7" => "http://schemas.opengis.net/gml/3.7.1/gml.xsd",
-              "http://www.isotc211.org/2005/gmd" => "http://schemas.opengis.net/iso/19139/20070417/gmd/gmd.xsd",
-            },
-            prefix: "xsi",
-            namespace: "http://another-instance",
-          ),
-          text: ["Some text inside paragraph"],
-        ),
-      )
+    context "with default namespace" do
+      before do
+        mapping.root("ceramic")
+        mapping.namespace("https://example.com/ceramic/1.2")
+        mapping.map_element("type", to: :type)
+        mapping.map_element("color", to: :color, delegate: :glaze)
+        mapping.map_element("finish", to: :finish, delegate: :glaze)
+      end
 
-      serialized = paragraph.to_xml
-      expect(serialized).to be_equivalent_to(xml)
-    end
-  end
+      it "sets the default namespace for the root element" do
+        expect(mapping.namespace_uri).to eq("https://example.com/ceramic/1.2")
+        expect(mapping.namespace_prefix).to be_nil
+      end
 
-  context "with raw mapping" do
-    let(:input_xml) do
-      <<~XML
-        <person>
-          <name>John Doe</name>
-          <address>
-            <street>
-              <a>N</a>
-              <p>adf</p>
-            </street>
-            <city><a>M</a></city>
-          </address>
-        </person>
-      XML
+      it "maps elements correctly" do
+        expect(mapping.elements.size).to eq(3)
+        expect(mapping.elements[0].name).to eq("type")
+        expect(mapping.elements[1].delegate).to eq(:glaze)
+      end
     end
 
-    let(:expected_street) do
-      if Lutaml::Model::Config.xml_adapter == Lutaml::Model::XmlAdapter::OxAdapter
-        "<a>N</a>\n<p>adf</p>\n"
-      else
-        "\n      <a>N</a>\n      <p>adf</p>\n    "
+    context "with prefixed namespace" do
+      before do
+        mapping.root("ceramic")
+        mapping.namespace("https://example.com/ceramic/1.2", "cera")
+        mapping.map_element("type", to: :type)
+        mapping.map_element("color", to: :color, delegate: :glaze)
+        mapping.map_element("finish", to: :finish, delegate: :glaze)
       end
-    end
 
-    let(:model) { XmlMapping::Person.from_xml(input_xml) }
+      it "sets the namespace with prefix for the root element" do
+        expect(mapping.namespace_uri).to eq("https://example.com/ceramic/1.2")
+        expect(mapping.namespace_prefix).to eq("cera")
+      end
 
-    it "expect to contain raw xml" do
-      expect(model.address.street).to eq(expected_street)
-      expect(model.address.city.strip).to eq("<a>M</a>")
+      it "maps elements correctly" do
+        expect(mapping.elements.size).to eq(3)
+        expect(mapping.elements[0].name).to eq("type")
+        expect(mapping.elements[1].delegate).to eq(:glaze)
+      end
     end
-  end
 
-  context "with content mapping" do
-    let(:xml_data) { "<i>my text <b>bold</b> is in italics</i>" }
-    let(:italic) { Italic.from_xml(xml_data) }
+    context "with element-level namespace" do
+      before do
+        mapping.root("ceramic")
+        mapping.map_element(
+          "type",
+          to: :type,
+          namespace: "https://example.com/ceramic/1.2",
+          prefix: "cera",
+        )
+        mapping.map_element("color", to: :color, delegate: :glaze)
+        mapping.map_element("finish", to: :finish, delegate: :glaze)
+      end
 
-    it "parses the textual content of an XML element" do
-      expect(italic.text).to eq(["my text ", " is in italics"])
+      it "sets the namespace for individual elements" do
+        expect(mapping.elements.size).to eq(3)
+        expect(mapping.elements[0].namespace).to eq("https://example.com/ceramic/1.2")
+        expect(mapping.elements[0].prefix).to eq("cera")
+        expect(mapping.elements[1].delegate).to eq(:glaze)
+      end
     end
-  end
 
-  context "with p object" do
-    describe "convert from xml containing p tag" do
-      let(:xml_data) { "<p>my text for paragraph</p>" }
-      let(:paragraph) { Paragraph.from_xml(xml_data) }
+    context "with attribute-level namespace" do
+      before do
+        mapping.root("ceramic")
+        mapping.map_attribute(
+          "date",
+          to: :date,
+          namespace: "https://example.com/ceramic/1.2",
+          prefix: "cera",
+        )
+        mapping.map_element("type", to: :type)
+        mapping.map_element("color", to: :color, delegate: :glaze)
+        mapping.map_element("finish", to: :finish, delegate: :glaze)
+      end
 
-      it "parses the textual content of an XML element" do
-        expect(paragraph.text).to eq("my text for paragraph")
+      it "sets the namespace for individual attributes" do
+        expect(mapping.attributes.size).to eq(1)
+        expect(mapping.attributes[0].namespace).to eq("https://example.com/ceramic/1.2")
+        expect(mapping.attributes[0].prefix).to eq("cera")
       end
     end
 
-    describe "generate xml with p tag" do
-      let(:paragraph) { Paragraph.new(text: "my text for paragraph") }
-      let(:expected_xml) { "<p>my text for paragraph</p>" }
-
-      it "converts to xml correctly" do
-        expect(paragraph.to_xml).to eq(expected_xml)
+    context "with nil element-level namespace" do
+      let(:expected_xml) do
+        <<~XML
+          <xmi:ChildNamespaceNil xmlns:xmi="http://www.omg.org/spec/XMI/20131001" xmlns:new="http://www.omg.org/spec/XMI/20161001">
+            <xmi:ElementDefaultNamespace>Default namespace</xmi:ElementDefaultNamespace>
+            <ElementNilNamespace>No namespace</ElementNilNamespace>
+            <new:ElementNewNamespace>New namespace</new:ElementNewNamespace>
+          </xmi:ChildNamespaceNil>
+        XML
       end
-    end
-  end
 
-  describe "#deep_dup" do
-    let(:orig_mappings) do
-      XmlMapping::ToBeDuplicated.mappings_for(:xml)
-    end
+      let(:model) do
+        XmlMapping::ChildNamespaceNil.new(
+          {
+            element_default_namespace: "Default namespace",
+            element_nil_namespace: "No namespace",
+            element_new_namespace: "New namespace",
+          },
+        )
+      end
 
-    let(:dup_mappings) do
-      orig_mappings.deep_dup
+      it "expect to apply correct namespaces" do
+        expect(model.to_xml).to be_equivalent_to(expected_xml)
+      end
     end
 
-    it "duplicates root_element" do
-      orig_root = orig_mappings.root_element
-      dup_root = dup_mappings.root_element
+    context "with schemaLocation" do
+      context "when mixed: false" do
+        let(:xml) do
+          <<~XML
+            <p xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+               xsi:schemaLocation="http://www.opengis.net/gml/3.2 http://schemas.opengis.net/gml/3.2.1/gml.xsd">
+              <p xmlns:xsi="http://another-instance"
+                 xsi:schemaLocation="http://www.opengis.net/gml/3.7">
+                Some text inside paragraph
+              </p>
+            </p>
+          XML
+        end
 
-      expect(orig_root).to eq(dup_root)
-      expect(orig_root.object_id).not_to eq(dup_root.object_id)
-    end
+        it "contain schemaLocation attributes" do
+          expect(Paragraph.from_xml(xml).to_xml).to be_equivalent_to(xml)
+        end
+      end
 
-    it "duplicates namespace_uri" do
-      orig_namespace_uri = orig_mappings.namespace_uri
-      dup_namespace_uri = dup_mappings.namespace_uri
+      context "when mixed: true" do
+        let(:xml) do
+          <<~XML
+            <schemaLocationOrdered xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+               xsi:schemaLocation="http://www.opengis.net/gml/3.2 http://schemas.opengis.net/gml/3.2.1/gml.xsd">
+              <schemaLocationOrdered xmlns:xsi="http://another-instance"
+                 xsi:schemaLocation="http://www.opengis.net/gml/3.7">
+                Some text inside paragraph
+              </schemaLocationOrdered>
+            </schemaLocationOrdered>
+          XML
+        end
 
-      expect(orig_namespace_uri).to eq(dup_namespace_uri)
-      expect(orig_namespace_uri.object_id).not_to eq(dup_namespace_uri.object_id)
+        it "contain schemaLocation attributes" do
+          expect(XmlMapping::SchemaLocationOrdered.from_xml(xml).to_xml).to be_equivalent_to(xml)
+        end
+      end
     end
 
-    it "duplicates namespace_prefix" do
-      orig_namespace_prefix = orig_mappings.namespace_prefix
-      dup_namespace_prefix = dup_mappings.namespace_prefix
+    context "with multiple schemaLocations" do
+      let(:xml) do
+        <<~XML
+          <p xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+             xsi:schemaLocation="http://www.opengis.net/gml/3.2 http://schemas.opengis.net/gml/3.2.1/gml.xsd http://www.w3.org/1999/xlink http://www.w3.org/1999/xlink.xsd">
+            <p xmlns:xsi="http://another-instance"
+               xsi:schemaLocation="http://www.opengis.net/gml/3.7 http://schemas.opengis.net/gml/3.7.1/gml.xsd http://www.isotc211.org/2005/gmd http://schemas.opengis.net/iso/19139/20070417/gmd/gmd.xsd">
+              Some text inside paragraph
+            </p>
+          </p>
+        XML
+      end
 
-      expect(orig_namespace_prefix).to eq(dup_namespace_prefix)
-      expect(orig_namespace_prefix.object_id).not_to eq(dup_namespace_prefix.object_id)
-    end
+      it "parses and serializes multiple schemaLocation attributes" do
+        parsed = Paragraph.from_xml(xml)
+        expect(parsed.schema_location.size).to eq(2)
+        expect(parsed.schema_location[0].namespace).to eq("http://www.opengis.net/gml/3.2")
+        expect(parsed.schema_location[0].location).to eq("http://schemas.opengis.net/gml/3.2.1/gml.xsd")
+        expect(parsed.schema_location[1].namespace).to eq("http://www.w3.org/1999/xlink")
+        expect(parsed.schema_location[1].location).to eq("http://www.w3.org/1999/xlink.xsd")
+
+        serialized = parsed.to_xml
+        expect(serialized).to be_equivalent_to(xml)
+        expect(serialized).to include('xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"')
+        expect(serialized).to include('xsi:schemaLocation="http://www.opengis.net/gml/3.2 http://schemas.opengis.net/gml/3.2.1/gml.xsd http://www.w3.org/1999/xlink http://www.w3.org/1999/xlink.xsd"')
+      end
 
-    context "when duplicating mapping" do
-      let(:orig_mapping) { orig_mappings.mappings[0] }
-      let(:dup_mapping) { dup_mappings.mappings[0] }
+      it "handles nested elements with different schemaLocations" do
+        parsed = Paragraph.from_xml(xml)
+        nested_p = parsed.paragraph
 
-      it "duplicates custom_methods" do
-        orig_custom_methods = orig_mapping.custom_methods
-        dup_custom_methods = dup_mapping.custom_methods
+        expect(nested_p).to be_a(Paragraph)
+        expect(nested_p.schema_location.size).to eq(2)
+        expect(nested_p.schema_location[0].namespace).to eq("http://www.opengis.net/gml/3.7")
+        expect(nested_p.schema_location[0].location).to eq("http://schemas.opengis.net/gml/3.7.1/gml.xsd")
+        expect(nested_p.schema_location[1].namespace).to eq("http://www.isotc211.org/2005/gmd")
+        expect(nested_p.schema_location[1].location).to eq("http://schemas.opengis.net/iso/19139/20070417/gmd/gmd.xsd")
 
-        expect(orig_custom_methods).to eq(dup_custom_methods)
-        expect(orig_custom_methods.object_id).not_to eq(dup_custom_methods.object_id)
+        serialized = parsed.to_xml
+        expect(serialized).to include('xmlns:xsi="http://another-instance"')
+        expect(serialized).to include('xsi:schemaLocation="http://www.opengis.net/gml/3.7 http://schemas.opengis.net/gml/3.7.1/gml.xsd http://www.isotc211.org/2005/gmd http://schemas.opengis.net/iso/19139/20070417/gmd/gmd.xsd"')
       end
 
-      it "duplicates default_namespace" do
-        orig_default_namespace = orig_mapping.default_namespace
-        dup_default_namespace = dup_mapping.default_namespace
+      it "creates XML with multiple schemaLocations" do
+        paragraph = Paragraph.new(
+          schema_location: Lutaml::Model::SchemaLocation.new(
+            schema_location: {
+              "http://www.opengis.net/gml/3.2" => "http://schemas.opengis.net/gml/3.2.1/gml.xsd",
+              "http://www.w3.org/1999/xlink" => "http://www.w3.org/1999/xlink.xsd",
+            },
+            prefix: "xsi",
+          ),
+          paragraph: Paragraph.new(
+            schema_location: Lutaml::Model::SchemaLocation.new(
+              schema_location: {
+                "http://www.opengis.net/gml/3.7" => "http://schemas.opengis.net/gml/3.7.1/gml.xsd",
+                "http://www.isotc211.org/2005/gmd" => "http://schemas.opengis.net/iso/19139/20070417/gmd/gmd.xsd",
+              },
+              prefix: "xsi",
+              namespace: "http://another-instance",
+            ),
+            text: ["Some text inside paragraph"],
+          ),
+        )
 
-        expect(orig_default_namespace).to eq(dup_default_namespace)
-        expect(orig_default_namespace.object_id).not_to eq(dup_default_namespace.object_id)
+        serialized = paragraph.to_xml
+        expect(serialized).to be_equivalent_to(xml)
       end
+    end
 
-      it "duplicates delegate" do
-        # `delegate` is symbol which are constant so object_id will be same
-        expect(orig_mapping.delegate).to eq(dup_mapping.delegate)
+    context "with raw mapping" do
+      let(:input_xml) do
+        <<~XML
+          <person>
+            <name>John Doe</name>
+            <address>
+              <street>
+                <a>N</a>
+                <p>adf</p>
+              </street>
+              <city><a>M</a></city>
+            </address>
+          </person>
+        XML
       end
 
-      it "duplicates mixed_content" do
-        # boolean value is constant so object_id will be same
-        expect(orig_mapping.mixed_content).to eq(dup_mapping.mixed_content)
+      let(:expected_street) do
+        if Lutaml::Model::Config.xml_adapter == Lutaml::Model::XmlAdapter::OxAdapter
+          "<a>N</a>\n<p>adf</p>\n"
+        else
+          "\n      <a>N</a>\n      <p>adf</p>\n    "
+        end
       end
 
-      it "duplicates name" do
-        orig_name = orig_mapping.name
-        dup_name = dup_mapping.name
+      let(:model) { XmlMapping::Person.from_xml(input_xml) }
 
-        expect(orig_name).to eq(dup_name)
-        expect(orig_name.object_id).not_to eq(dup_name.object_id)
+      it "expect to contain raw xml" do
+        expect(model.address.street).to eq(expected_street)
+        expect(model.address.city.strip).to eq("<a>M</a>")
       end
+    end
 
-      it "duplicates namespace" do
-        orig_namespace = orig_mapping.namespace
-        dup_namespace = dup_mapping.namespace
+    context "with content mapping" do
+      let(:xml_data) { "<i>my text <b>bold</b> is in italics</i>" }
+      let(:italic) { Italic.from_xml(xml_data) }
 
-        expect(orig_namespace).to eq(dup_namespace)
-        expect(orig_namespace.object_id).not_to eq(dup_namespace.object_id)
+      it "parses the textual content of an XML element" do
+        expect(italic.text).to eq(["my text ", " is in italics"])
       end
+    end
 
-      it "duplicates namespace_set" do
-        # boolean value is constant so object_id will be same
-        expect(orig_mapping.namespace_set?).to eq(dup_mapping.namespace_set?)
+    context "with p object" do
+      describe "convert from xml containing p tag" do
+        let(:xml_data) { "<p>my text for paragraph</p>" }
+        let(:paragraph) { Paragraph.from_xml(xml_data) }
+
+        it "parses the textual content of an XML element" do
+          expect(paragraph.text).to eq("my text for paragraph")
+        end
       end
 
-      it "duplicates prefix" do
-        orig_prefix = orig_mapping.prefix
-        dup_prefix = dup_mapping.prefix
+      describe "generate xml with p tag" do
+        let(:paragraph) { Paragraph.new(text: "my text for paragraph") }
+        let(:expected_xml) { "<p>my text for paragraph</p>" }
 
-        expect(orig_prefix).to eq(dup_prefix)
-        expect(orig_prefix.object_id).not_to eq(dup_prefix.object_id)
+        it "converts to xml correctly" do
+          expect(paragraph.to_xml.chomp).to eq(expected_xml)
+        end
       end
+    end
 
-      it "duplicates prefix_set" do
-        # boolean value is constant so object_id will be same
-        expect(orig_mapping.prefix_set?).to eq(dup_mapping.prefix_set?)
+    describe "#deep_dup" do
+      let(:orig_mappings) do
+        XmlMapping::ToBeDuplicated.mappings_for(:xml)
       end
 
-      it "duplicates render_nil" do
-        # boolean value is constant so object_id will be same
-        expect(orig_mapping.render_nil?).to eq(dup_mapping.render_nil?)
+      let(:dup_mappings) do
+        orig_mappings.deep_dup
       end
 
-      it "duplicates to" do
-        # `to` is symbol which are constant so object_id will be same
-        expect(orig_mapping.to).to eq(dup_mapping.to)
+      it "duplicates root_element" do
+        orig_root = orig_mappings.root_element
+        dup_root = dup_mappings.root_element
+
+        expect(orig_root).to eq(dup_root)
+        expect(orig_root.object_id).not_to eq(dup_root.object_id)
       end
-    end
-  end
 
-  describe "#map_all" do
-    context "when map_all is defined before any other mapping" do
-      let(:error_message) { "no other mappings are allowed with map_all" }
+      it "duplicates namespace_uri" do
+        orig_namespace_uri = orig_mappings.namespace_uri
+        dup_namespace_uri = dup_mappings.namespace_uri
 
-      it "raise error when for map_element with map_all" do
-        expect do
-          XmlMapping::WithMapAll.xml do
-            map_element "ele", to: :ele
-          end
-        end.to raise_error(StandardError, error_message)
+        expect(orig_namespace_uri).to eq(dup_namespace_uri)
+        expect(orig_namespace_uri.object_id).not_to eq(dup_namespace_uri.object_id)
       end
 
-      it "raise error when for map_attribute with map_all" do
-        expect do
-          XmlMapping::WithMapAll.xml do
-            map_attribute "attr", to: :attr
-          end
-        end.to raise_error(StandardError, error_message)
+      it "duplicates namespace_prefix" do
+        orig_namespace_prefix = orig_mappings.namespace_prefix
+        dup_namespace_prefix = dup_mappings.namespace_prefix
+
+        expect(orig_namespace_prefix).to eq(dup_namespace_prefix)
+        expect(orig_namespace_prefix.object_id).not_to eq(dup_namespace_prefix.object_id)
       end
 
-      it "raise error when for map_content with map_all" do
-        expect do
-          XmlMapping::WithMapAll.xml do
-            map_content to: :text
-          end
-        end.to raise_error(StandardError, error_message)
+      context "when duplicating mapping" do
+        let(:orig_mapping) { orig_mappings.mappings[0] }
+        let(:dup_mapping) { dup_mappings.mappings[0] }
+
+        it "duplicates custom_methods" do
+          orig_custom_methods = orig_mapping.custom_methods
+          dup_custom_methods = dup_mapping.custom_methods
+
+          expect(orig_custom_methods).to eq(dup_custom_methods)
+          expect(orig_custom_methods.object_id).not_to eq(dup_custom_methods.object_id)
+        end
+
+        it "duplicates default_namespace" do
+          orig_default_namespace = orig_mapping.default_namespace
+          dup_default_namespace = dup_mapping.default_namespace
+
+          expect(orig_default_namespace).to eq(dup_default_namespace)
+          expect(orig_default_namespace.object_id).not_to eq(dup_default_namespace.object_id)
+        end
+
+        it "duplicates delegate" do
+          # `delegate` is symbol which are constant so object_id will be same
+          expect(orig_mapping.delegate).to eq(dup_mapping.delegate)
+        end
+
+        it "duplicates mixed_content" do
+          # boolean value is constant so object_id will be same
+          expect(orig_mapping.mixed_content).to eq(dup_mapping.mixed_content)
+        end
+
+        it "duplicates name" do
+          orig_name = orig_mapping.name
+          dup_name = dup_mapping.name
+
+          expect(orig_name).to eq(dup_name)
+          expect(orig_name.object_id).not_to eq(dup_name.object_id)
+        end
+
+        it "duplicates namespace" do
+          orig_namespace = orig_mapping.namespace
+          dup_namespace = dup_mapping.namespace
+
+          expect(orig_namespace).to eq(dup_namespace)
+          expect(orig_namespace.object_id).not_to eq(dup_namespace.object_id)
+        end
+
+        it "duplicates namespace_set" do
+          # boolean value is constant so object_id will be same
+          expect(orig_mapping.namespace_set?).to eq(dup_mapping.namespace_set?)
+        end
+
+        it "duplicates prefix" do
+          orig_prefix = orig_mapping.prefix
+          dup_prefix = dup_mapping.prefix
+
+          expect(orig_prefix).to eq(dup_prefix)
+          expect(orig_prefix.object_id).not_to eq(dup_prefix.object_id)
+        end
+
+        it "duplicates prefix_set" do
+          # boolean value is constant so object_id will be same
+          expect(orig_mapping.prefix_set?).to eq(dup_mapping.prefix_set?)
+        end
+
+        it "duplicates render_nil" do
+          # boolean value is constant so object_id will be same
+          expect(orig_mapping.render_nil?).to eq(dup_mapping.render_nil?)
+        end
+
+        it "duplicates to" do
+          # `to` is symbol which are constant so object_id will be same
+          expect(orig_mapping.to).to eq(dup_mapping.to)
+        end
       end
     end
 
-    context "when map_all is defined after other mappings" do
-      let(:error_message) { "map_all is not allowed with other mappings" }
-
-      it "raise error when for map_element with map_all" do
-        expect do
-          XmlMapping::WithoutMapAll.xml do
-            map_all to: :all_content
-          end
-        end.to raise_error(StandardError, error_message)
+    describe "#map_all" do
+      context "when map_all is defined before any other mapping" do
+        it "raise error when for map_element with map_all" do
+          expect do
+            XmlMapping::WithMapAll.xml do
+              map_element "ele", to: :ele
+            end
+          end.to raise_error(
+            StandardError,
+            "map_element is not allowed, only map_attribute is allowed with map_all",
+          )
+        end
+
+        it "raise error when for map_content with map_all" do
+          expect do
+            XmlMapping::WithMapAll.xml do
+              map_content to: :text
+            end
+          end.to raise_error(
+            StandardError,
+            "map_content is not allowed, only map_attribute is allowed with map_all",
+          )
+        end
+
+        it "does not raise error for map_attribute with map_all" do
+          expect do
+            XmlMapping::WithMapAll.xml do
+              map_attribute "attr", to: :attr
+            end
+          end.not_to raise_error
+        end
       end
-    end
 
-    it "maps all the content including tags" do
-      inner_xml = "Str<sub>2</sub>text<sup>1</sup>123"
-      xml = "<WithMapAll>#{inner_xml}</WithMapAll>"
+      context "when map_all is defined after other mappings" do
+        let(:error_message) { "map_all is not allowed with other mappings" }
 
-      parsed = XmlMapping::WithMapAll.from_xml(xml)
+        it "raise error when for map_element with map_all" do
+          expect do
+            XmlMapping::WithoutMapAll.xml do
+              map_all to: :all_content
+            end
+          end.to raise_error(StandardError, error_message)
+        end
+      end
 
-      expect(parsed.all_content).to eq(inner_xml)
-    end
+      context "with custom methods" do
+        let(:inner_xml) do
+          "Str<sub>2</sub>text<sup>1</sup>123"
+        end
 
-    it "round-trips xml" do
-      xml = "<WithMapAll>Str<sub>2</sub>text<sup>1</sup>123</WithMapAll>"
-      expected_xml = "<WithMapAll>Str&lt;sub&gt;2&lt;/sub&gt;text&lt;sup&gt;1&lt;/sup&gt;123</WithMapAll>"
+        let(:xml) do
+          "<MapAllWithCustomMethod>#{inner_xml}</MapAllWithCustomMethod>"
+        end
 
-      expect(XmlMapping::WithMapAll.from_xml(xml).to_xml).to eq(expected_xml)
-    end
+        let(:parsed) do
+          XmlMapping::MapAllWithCustomMethod.from_xml(xml)
+        end
 
-    context "when nested content has map_all" do
-      let(:description) do
-        <<~DESCRIPTION
-          I'm a <b>web developer</b> with <strong>years</strong> of
-          <i>experience</i> in many programing languages.
-        DESCRIPTION
-      end
+        it "uses custom method when parsing XML" do
+          expect(parsed.all_content).to eq("<div>#{inner_xml}</div>")
+        end
 
-      let(:expected_description) do
-        <<~DESCRIPTION
-          I'm a &lt;b&gt;web developer&lt;/b&gt; with &lt;strong&gt;years&lt;/strong&gt; of
-          &lt;i&gt;experience&lt;/i&gt; in many programing languages.
-        DESCRIPTION
+        it "generates correct XML" do
+          expect(parsed.to_xml.chomp).to be_equivalent_to(xml)
+        end
       end
 
-      let(:xml) do
-        <<~XML
-          <WithNestedMapAll age="23">
-            <name>John Doe</name>
-            <description>
-              #{description}
-            </description>
-          </WithNestedMapAll>
-        XML
-      end
+      it "maps all the content including tags" do
+        inner_xml = "Str<sub>2</sub>text<sup>1</sup>123"
+        xml = "<WithMapAll>#{inner_xml}</WithMapAll>"
 
-      let(:expected_xml) do
-        <<~XML
-          <WithNestedMapAll age="23">
-            <name>John Doe</name>
-            <description>
-              #{expected_description}
-            </description>
-          </WithNestedMapAll>
-        XML
-      end
+        parsed = XmlMapping::WithMapAll.from_xml(xml)
 
-      let(:parsed) do
-        XmlMapping::WithNestedMapAll.from_xml(xml)
+        expect(parsed.all_content).to eq(inner_xml)
       end
 
-      it "maps description correctly" do
-        expect(parsed.description.all_content.strip).to eq(description.strip)
-      end
+      it "round-trips xml" do
+        xml = "<WithMapAll>Str<sub>2</sub>text<sup>1</sup>123</WithMapAll>"
 
-      it "maps name correctly" do
-        expect(parsed.name).to eq("John Doe")
+        expect(XmlMapping::WithMapAll.from_xml(xml).to_xml.chomp).to eq(xml)
       end
 
-      it "maps age correctly" do
-        expect(parsed.age).to eq(23)
+      context "when nested content has map_all" do
+        let(:description) do
+          <<~DESCRIPTION
+            I'm a <b>web developer</b> with <strong>years</strong> of <i>experience</i> in many programing languages.
+          DESCRIPTION
+        end
+
+        let(:expected_description) do
+          <<~DESCRIPTION
+            I'm a <b>web developer</b> with <strong>years</strong> of <i>experience</i> in many programing languages.
+          DESCRIPTION
+        end
+
+        let(:xml) do
+          <<~XML
+            <WithNestedMapAll age="23">
+              <name>John Doe</name>
+              <description>
+                #{description}
+              </description>
+            </WithNestedMapAll>
+          XML
+        end
+
+        let(:expected_xml) do
+          <<~XML
+            <WithNestedMapAll age="23">
+              <name>John Doe</name>
+              <description>
+                #{expected_description}
+              </description>
+            </WithNestedMapAll>
+          XML
+        end
+
+        let(:parsed) do
+          XmlMapping::WithNestedMapAll.from_xml(xml)
+        end
+
+        it "maps description correctly" do
+          expect(parsed.description.all_content.strip).to eq(description.strip)
+        end
+
+        it "maps name correctly" do
+          expect(parsed.name).to eq("John Doe")
+        end
+
+        it "maps age correctly" do
+          expect(parsed.age).to eq(23)
+        end
+
+        it "round-trips xml" do
+          expect(parsed.to_xml).to be_equivalent_to(expected_xml)
+        end
       end
 
-      it "round-trips xml" do
-        expect(parsed.to_xml).to be_equivalent_to(expected_xml)
+      context "when special char used in content with map all" do
+        let(:xml) do
+          <<~XML
+            <SpecialCharContentWithMapAll>
+              B <p>R&#x0026;C</p>
+              C <p>J&#8212;C</p>
+              O <p>A &amp; B </p>
+              F <p>Z &#x00A9; </p>
+            </SpecialCharContentWithMapAll>
+          XML
+        end
+
+        let(:expected_nokogiri_xml) do
+          <<~XML.strip
+            <SpecialCharContentWithMapAll>
+              B <p>R&amp;C</p>
+              C <p>J—C</p>
+              O <p>A &amp; B </p>
+              F <p>Z © </p>
+            </SpecialCharContentWithMapAll>
+          XML
+        end
+
+        let(:expected_ox_xml) do
+          "<SpecialCharContentWithMapAll> " \
+            "B <p>R&amp;C</p> " \
+            "C <p>J—C</p> " \
+            "O <p>A &amp; B </p> " \
+            "F <p>Z © </p>" \
+            "</SpecialCharContentWithMapAll>\n"
+        end
+
+        it "round-trips xml" do
+          expected_xml = if adapter_class == Lutaml::Model::XmlAdapter::NokogiriAdapter
+                           expected_nokogiri_xml
+                         else
+                           expected_ox_xml
+                         end
+
+          expect(XmlMapping::SpecialCharContentWithMapAll.from_xml(xml).to_xml).to eq(expected_xml)
+        end
       end
-    end
-
-    context "when special char used in content with map all" do
-      it "round-trips xml" do
-        xml = <<~XML
-          <SpecialCharContentWithMapAll>
-            B <p>R&#x0026;C</p>
-            C <p>J&#8212;C</p>
-            O <p>A &amp; B </p>
-            F <p>Z &#x00A9; </p>
-          </SpecialCharContentWithMapAll>
-        XML
 
-        expected_xml = <<~XML.strip
-          <SpecialCharContentWithMapAll>
-            B &lt;p&gt;R&amp;amp;C&lt;/p&gt;
-            C &lt;p&gt;J&amp;#x2014;C&lt;/p&gt;
-            O &lt;p&gt;A &amp;amp; B &lt;/p&gt;
-            F &lt;p&gt;Z &amp;#xA9; &lt;/p&gt;
-          </SpecialCharContentWithMapAll>
-        XML
-
-        expect(XmlMapping::SpecialCharContentWithMapAll.from_xml(xml).to_xml).to eq(expected_xml)
+      context "when mixed content is true and child is content_mapping" do
+        let(:xml) do
+          <<~XML
+            <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+              <xsd:documentation>asdf</xsd:documentation>
+            </xsd:schema>
+          XML
+        end
+
+        it "round-trips xml" do
+          expect(XmlMapping::Schema.from_xml(xml).to_xml).to be_equivalent_to(xml)
+        end
       end
     end
+  end
 
-    context "when mixed content is true and child is content_mapping" do
-      let(:xml) do
-        <<~XML
-          <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-            <xsd:documentation>asdf</xsd:documentation>
-          </xsd:schema>
-        XML
-      end
+  describe Lutaml::Model::XmlAdapter::NokogiriAdapter do
+    it_behaves_like "having XML Mappings", described_class
+  end
 
-      it "round-trips xml" do
-        expect(XmlMapping::Schema.from_xml(xml).to_xml).to be_equivalent_to(xml)
-      end
-    end
+  describe Lutaml::Model::XmlAdapter::OxAdapter do
+    it_behaves_like "having XML Mappings", described_class
+  end
+
+  describe Lutaml::Model::XmlAdapter::OgaAdapter, skip: "Not implemented yet" do
+    it_behaves_like "having XML Mappings", described_class
   end
 end