lutaml-model 0.8.8 → 0.8.10

data/lib/lutaml/xml/schema/xsd/choice.rb

@@ -41,7 +41,7 @@ module Lutaml
             resolved_element_order&.each do |child|
               if child.is_a?(Element)
                 array << child
-              elsif child.respond_to?(:child_elements)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.child_elements(array)
               end
             end
@@ -54,7 +54,7 @@ module Lutaml
             resolved_element_order&.any? do |child|
               if child.is_a?(Element)
                 reference_matches?(element_name, child.ref || child.name)
-              elsif child.respond_to?(:find_elements_used)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.find_elements_used(element_name)
               end
             end || false

data/lib/lutaml/xml/schema/xsd/complex_type.rb

@@ -105,7 +105,7 @@ except: DIRECT_CHILD_ELEMENTS_EXCEPTION)
             resolved_element_order&.each do |child|
               if child.is_a?(Element)
                 array << child
-              elsif child.respond_to?(:child_elements)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.child_elements(array)
               end
             end
@@ -118,7 +118,7 @@ except: DIRECT_CHILD_ELEMENTS_EXCEPTION)
             resolved_element_order&.any? do |child|
               if child.is_a?(Element)
                 reference_matches?(element_name, child.ref || child.name)
-              elsif child.respond_to?(:find_elements_used)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.find_elements_used(element_name)
               end
             end || false
@@ -139,9 +139,9 @@ except: DIRECT_CHILD_ELEMENTS_EXCEPTION)
           # Get elements from the primary content model (sequence, choice, or all).
           # @return [Array<Element>] Elements exposed by the active content model
           def elements
-            return sequence.element if sequence.respond_to?(:element)
-            return choice.element if choice.respond_to?(:element)
-            return all.element if all.respond_to?(:element)
+            return sequence.element if sequence
+            return choice.element if choice
+            return all.element if all
 
             []
           end

data/lib/lutaml/xml/schema/xsd/errors/message_builder.rb

@@ -28,8 +28,8 @@ module Lutaml
               parts = []
               parts << header
               parts << context_details if @error.context && !@error.context.to_h.empty?
-              parts << suggestions_section if @error.respond_to?(:suggestions) && @error.suggestions.any?
-              parts << troubleshooting_section if @error.respond_to?(:troubleshooting_tips) && @error.troubleshooting_tips.any?
+              parts << suggestions_section if @error.is_a?(EnhancedError) && @error.suggestions.any?
+              parts << troubleshooting_section if @error.is_a?(EnhancedError) && @error.troubleshooting_tips.any?
               parts.compact.join("\n\n")
             end
 
@@ -39,7 +39,7 @@ module Lutaml
             #
             # @return [String] Error header
             def header
-              severity = @error.respond_to?(:severity) ? @error.severity.to_s.upcase : "ERROR"
+              severity = @error.is_a?(EnhancedError) ? @error.severity.to_s.upcase : "ERROR"
               "#{severity}: #{@error.message}"
             end
 

data/lib/lutaml/xml/schema/xsd/group.rb

@@ -44,7 +44,7 @@ module Lutaml
             group.resolved_element_order&.each do |child|
               if child.is_a?(Element)
                 array << child
-              elsif child.respond_to?(:child_elements)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.child_elements(array)
               end
             end
@@ -57,7 +57,7 @@ module Lutaml
             resolved_element_order&.any? do |child|
               if child.is_a?(Element)
                 reference_matches?(element_name, child.ref || child.name)
-              elsif child.respond_to?(:find_elements_used)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.find_elements_used(element_name)
               end
             end || false

data/lib/lutaml/xml/schema/xsd/schema_validator.rb

@@ -6,6 +6,9 @@ module Lutaml
   module Xml
     module Schema
       module Xsd
+        # Ensure error classes are loaded before SchemaValidator references them
+        Error # trigger autoload
+
         # Validates XSD schema documents before parsing
         #
         # This validator checks that XML content is a valid XSD schema document

data/lib/lutaml/xml/schema/xsd/sequence.rb

@@ -41,7 +41,7 @@ module Lutaml
             resolved_element_order&.each do |child|
               if child.is_a?(Element)
                 array << child
-              elsif child.respond_to?(:child_elements)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.child_elements(array)
               end
             end
@@ -54,7 +54,7 @@ module Lutaml
             resolved_element_order&.any? do |child|
               if child.is_a?(Element)
                 reference_matches?(element_name, child.ref || child.name)
-              elsif child.respond_to?(:find_elements_used)
+              elsif child.is_a?(Group) || child.is_a?(Sequence) || child.is_a?(Choice) || child.is_a?(ComplexType)
                 child.find_elements_used(element_name)
               end
             end || false

data/lib/lutaml/xml/schema/xsd_schema.rb

@@ -82,7 +82,7 @@ module Lutaml
             attr_type = attr.type(register)
 
             # Validate Type::Value xsd_type
-            if attr_type.respond_to?(:xsd_type)
+            if attr_type.is_a?(Class) && attr_type < Lutaml::Model::Type::Value
               type_name = attr_type.xsd_type
               classification = classify_xsd_type(type_name, klass, register)
 
@@ -413,7 +413,7 @@ _mapping_rule = nil)
           return attr.options[:xsd_type] if attr.options[:xsd_type]
 
           # 2. Check if type has xsd_type method (Type-level)
-          if attr_type.respond_to?(:xsd_type)
+          if attr_type.is_a?(Class) && attr_type < Lutaml::Model::Type::Value
             # Special handling for Reference type
             if attr_type == Lutaml::Model::Type::Reference
               target_xsd_type = get_target_xsd_type(attr, register)
@@ -466,7 +466,7 @@ _mapping_rule = nil)
 
           # Get namespace info from Model class (Serializable)
           def get_model_namespace_info(klass)
-            mapping = klass.respond_to?(:mappings_for) ? klass.mappings_for(:xml) : nil
+            mapping = klass.is_a?(Class) && klass.include?(Lutaml::Model::Serialize) ? klass.mappings_for(:xml) : nil
             return {} unless mapping
 
             {
@@ -487,8 +487,8 @@ _mapping_rule = nil)
 
             # XmlNamespace class
             {
-              uri: ns.respond_to?(:uri) ? ns.uri : nil,
-              prefix: ns.respond_to?(:prefix_default) ? ns.prefix_default : nil,
+              uri: ns.is_a?(Class) && ns < Lutaml::Xml::Namespace ? ns.uri : nil,
+              prefix: ns.is_a?(Class) && ns < Lutaml::Xml::Namespace ? ns.prefix_default : nil,
               class: ns,
             }
           end

data/lib/lutaml/xml/serialization/format_conversion.rb

@@ -97,7 +97,7 @@ module Lutaml
           raise Lutaml::Model::NoRootMappingError.new(self) unless valid
 
           options[:encoding] = doc.encoding
-          if doc.respond_to?(:doctype) && doc.doctype
+          if doc.is_a?(Lutaml::Xml::Document) && doc.doctype
             options[:doctype] = doc.doctype
           end
         end
@@ -214,7 +214,7 @@ module Lutaml
         def process_xml_mapping_class_inheritance(mapping_class, &block)
           # Start with a copy of the parent class's XML mapping (if any).
           parent_class = superclass_with_xml_mapping(self)
-          parent_xml_mapping = if parent_class.respond_to?(:mappings)
+          parent_xml_mapping = if parent_class.is_a?(Class) && parent_class.include?(Lutaml::Model::Serialize)
                                  parent_class.mappings[:xml]
                                end
           @xml_mapping = if parent_xml_mapping
@@ -224,7 +224,8 @@ module Lutaml
                          end
 
           # Get the parent mapping instance (DSL already evaluated via xml_mapping_instance)
-          parent_mapping = if mapping_class.respond_to?(:xml_mapping_instance) &&
+          parent_mapping = if mapping_class.is_a?(Class) &&
+              (mapping_class < Lutaml::Xml::Mapping || mapping_class.include?(Lutaml::Model::Serialize)) &&
               mapping_class.xml_mapping_instance
                              mapping_class.xml_mapping_instance
                            else

data/lib/lutaml/xml/transformation/element_builder.rb

@@ -91,7 +91,7 @@ parent_element_form_default)
             if attr_type.is_a?(Class) && attr_type.include?(Lutaml::Model::Serialize)
               attr_mapping = attr_type.mappings_for(:xml)
               attr_ns = attr_mapping&.namespace_class
-              attr_ns_param = attr_mapping&.send(:namespace_param)
+              attr_ns_param = attr_mapping&.namespace_param
               # Use child's explicit namespace if it differs from parent's
               # If child has no namespace declaration (nil) or explicit blank (:blank),
               # do NOT inherit parent's namespace - return nil
@@ -165,7 +165,9 @@ is_polymorphic_subtype)
             if polymorphic_config.is_a?(Hash)
               poly_attr = polymorphic_config[:attribute]
               poly_class_map = polymorphic_config[:class_map]
-              poly_value = value.send(poly_attr) if poly_attr && value.respond_to?(poly_attr)
+              poly_value = if poly_attr && value.is_a?(Lutaml::Model::Serialize) && value.class.attributes.key?(poly_attr)
+                             value.public_send(poly_attr)
+                           end
               if poly_value && poly_class_map && (klass_name = poly_class_map[poly_value.to_s])
                 Object.const_get(klass_name)
               else

data/lib/lutaml/xml/transformation/rule_applier.rb

@@ -241,8 +241,8 @@ register_id)
         def apply_custom_method(parent, rule, model_class, model_instance)
           wrapper = ::Lutaml::Xml::CustomMethodWrapper.new(parent)
           mapper_instance = model_class.new
-          mapper_instance.send(rule.custom_methods[:to], model_instance,
-                               parent, wrapper)
+          mapper_instance.public_send(rule.custom_methods[:to], model_instance,
+                                      parent, wrapper)
         end
 
         # Apply element value handling collections

data/lib/lutaml/xml/transformation/value_serializer.rb

@@ -54,7 +54,7 @@ module Lutaml
           end
 
           # Use type's serialization if available
-          if rule.attribute_type.respond_to?(:serialize)
+          if rule.attribute_type.is_a?(Class) && rule.attribute_type < Lutaml::Model::Type::Value
             rule.attribute_type.serialize(value)
           else
             value.to_s
@@ -101,7 +101,7 @@ module Lutaml
         # @param attribute_type [Class, nil] The attribute type
         # @return [Boolean] true if custom Value type
         def custom_value_type?(attribute_type)
-          attribute_type.respond_to?(:new) &&
+          attribute_type.is_a?(Class) &&
             attribute_type < Lutaml::Model::Type::Value
         end
 
@@ -112,14 +112,12 @@ module Lutaml
         # @return [String, nil] Serialized value or nil
         def serialize_custom_value(value, attribute_type)
           # Skip wrapping if value is already the correct type
-          if value.is_a?(attribute_type) && value.respond_to?(:to_xml)
+          if value.is_a?(attribute_type)
             return value.to_xml
           end
 
           wrapped_value = attribute_type.new(value)
-          if wrapped_value.respond_to?(:to_xml)
-            wrapped_value.to_xml
-          end
+          wrapped_value.to_xml
         end
 
         # Find attribute definition from model class

data/lib/lutaml/xml/transformation.rb

@@ -139,9 +139,9 @@ module Lutaml
       # @param model_instance [Object] The model instance
       def handle_schema_location(root, model_instance)
         # Case 1: SchemaLocation object (programmatic creation)
-        if model_instance.respond_to?(:schema_location) && model_instance.schema_location
+        if model_instance.is_a?(Lutaml::Model::Serialize) && model_instance.schema_location
           schema_loc = model_instance.schema_location
-          if schema_loc.respond_to?(:to_xml_attributes)
+          if schema_loc.is_a?(Lutaml::Xml::SchemaLocation)
             schema_attrs = schema_loc.to_xml_attributes
             schema_attrs.each do |attr_name, attr_value|
               attr = ::Lutaml::Xml::DataModel::XmlAttribute.new(attr_name,
@@ -150,7 +150,7 @@ module Lutaml
             end
           end
         # Case 2: @raw_schema_location string (from parsing/round-trip)
-        elsif model_instance.respond_to?(:raw_schema_location) && model_instance.raw_schema_location
+        elsif model_instance.is_a?(Lutaml::Model::Serialize) && model_instance.raw_schema_location
           raw_schema_loc = model_instance.raw_schema_location
           if raw_schema_loc && !raw_schema_loc.empty?
             add_raw_schema_location(root, raw_schema_loc)
@@ -292,7 +292,7 @@ module Lutaml
       # @param model_instance [Object] The model instance
       # @param options [Hash] Options
       def apply_standard_rules(root, model_instance, options)
-        attr_order = model_instance.respond_to?(:attribute_order) &&
+        attr_order = model_instance.is_a?(Lutaml::Model::Serialize) &&
           model_instance.attribute_order
 
         rules = if attr_order

data/lib/lutaml/xml/type/configurable.rb

@@ -104,9 +104,7 @@ module Lutaml
           # @return [String, nil] parent's xsd_type if set
           def inherited_xsd_type
             return nil if superclass == Lutaml::Model::Type::Value
-            return nil unless superclass.respond_to?(:xsd_type)
 
-            # Get parent's @xsd_type directly (not default_xsd_type)
             parent_xsd = superclass.instance_variable_get(:@xsd_type)
             parent_xsd || superclass.inherited_xsd_type
           end
@@ -116,7 +114,6 @@ module Lutaml
           # @return [Class, Symbol, nil] parent's namespace class if set
           def inherited_namespace
             return nil if superclass == Lutaml::Model::Type::Value
-            return nil unless superclass.respond_to?(:xml_mapping)
 
             parent_mapping = superclass.xml_mapping
             parent_mapping&.namespace_class || superclass.inherited_namespace
@@ -136,7 +133,6 @@ module Lutaml
           # @return [Lutaml::Xml::Type::ValueXmlMapping] the new XML mapping
           def inherit_xml_mapping_from_parent
             return create_xml_mapping if superclass == Lutaml::Model::Type::Value
-            return create_xml_mapping unless superclass.respond_to?(:xml_mapping)
 
             parent_mapping = superclass.xml_mapping
             return create_xml_mapping unless parent_mapping

data/lib/lutaml/xml/xml_element.rb

@@ -157,7 +157,7 @@ module Lutaml
       def name
         return @name unless namespace_prefix
 
-        @prefixed_name ||= "#{namespace_prefix}:#{@name}" # rubocop:disable Naming/MemoizedInstanceVariableName
+        @prefixed_name ||= -"#{namespace_prefix}:#{@name}" # rubocop:disable Naming/MemoizedInstanceVariableName
       end
 
       def namespaced_name
@@ -174,15 +174,18 @@ module Lutaml
           # 3. Fall back to namespaces[nil] if exists
           # 4. Return unprefixed name
           ns = namespaces
-          if namespace_prefix && ns[namespace_prefix]
-            "#{ns[namespace_prefix].uri}:#{@name}"
-          elsif @default_namespace
-            "#{@default_namespace}:#{@name}"
-          elsif ns[nil]
-            "#{ns[nil].uri}:#{@name}"
-          else
-            @name
-          end
+          raw = if namespace_prefix && ns[namespace_prefix]
+                  "#{ns[namespace_prefix].uri}:#{@name}"
+                elsif @default_namespace
+                  "#{@default_namespace}:#{@name}"
+                elsif ns[nil]
+                  "#{ns[nil].uri}:#{@name}"
+                else
+                  @name
+                end
+          # Deduplicate the string to reduce GC pressure from repeated
+          # namespace URIs across thousands of elements.
+          -raw
         end
       end
 
@@ -236,7 +239,8 @@ module Lutaml
 
         @namespace_uri = begin
           ns = namespace
-          ns&.uri
+          uri = ns&.uri
+          uri ? -uri : nil
         end
       end
 
@@ -296,9 +300,13 @@ module Lutaml
 
       def text
         return @text if children.empty?
-        return text_children.map(&:text) if content_bearing_children_count > 1
+        return @computed_text if defined?(@computed_text)
 
-        text_children.map(&:text).join
+        @computed_text = if content_bearing_children_count > 1
+                           text_children.map(&:text)
+                         else
+                           text_children.map(&:text).join
+                         end
       end
 
       def cdata

data/lutaml-model.gemspec

@@ -36,7 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "canon"
   spec.add_dependency "concurrent-ruby"
   spec.add_dependency "liquid", ">= 4.0", "< 6.0"
-  spec.add_dependency "moxml", ">= 0.1.16"
+  spec.add_dependency "moxml", ">= 0.1.20"
   spec.add_dependency "ostruct"
   spec.add_dependency "rubyzip", "~> 2.3"
   spec.add_dependency "thor"

data/spec/lutaml/model/cached_type_resolver_spec.rb

@@ -129,14 +129,14 @@ RSpec.describe Lutaml::Model::CachedTypeResolver do
       expect(result2).to eq(result1)
     end
 
-    it "passes through Class objects without caching" do
+    it "caches Class objects with substitution applied" do
       klass = Class.new
       result = resolver.resolve(klass, context)
       expect(result).to eq(klass)
 
-      # Should not be cached
+      # Should be cached
       stats = resolver.cache_stats
-      expect(stats[:size]).to eq(0)
+      expect(stats[:size]).to eq(1)
     end
 
     it "raises UnknownTypeError for unknown types" do

data/spec/lutaml/model/optimization_spec.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Optimization behaviors" do
+  before do
+    Lutaml::Model::GlobalContext.clear_caches
+    Lutaml::Model::TransformationRegistry.instance.clear
+    Lutaml::Model::GlobalRegister.instance.reset
+    Lutaml::Model::Store.clear
+  end
+
+  after do
+    Lutaml::Model::GlobalContext.clear_caches
+    Lutaml::Model::TransformationRegistry.instance.clear
+    Lutaml::Model::GlobalRegister.instance.reset
+    Lutaml::Model::Store.clear
+  end
+
+  describe "DeserializationContext propagation" do
+    let(:propagation_keys) do
+      Lutaml::Model::Serialize::DeserializationContext::PROPAGATION_KEYS
+    end
+
+    it "propagates only whitelisted keys" do
+      options = {
+        lutaml_parent: "parent",
+        lutaml_root: "root",
+        default_namespace: "http://example.com",
+        namespace_uri: "http://internal.com",
+        resolved_type: String,
+        converted: true,
+        polymorphic: :by_type,
+        collection: true,
+      }
+
+      propagated = Lutaml::Model::Serialize::DeserializationContext.propagate(options)
+
+      expect(propagated).to eq({
+                                 lutaml_parent: "parent",
+                                 lutaml_root: "root",
+                                 default_namespace: "http://example.com",
+                                 polymorphic: :by_type,
+                                 collection: true,
+                               })
+    end
+
+    it "excludes parent-internal keys" do
+      options = {
+        namespace_uri: "http://internal.com",
+        resolved_type: String,
+        converted: true,
+        mappings: double("mappings"),
+      }
+
+      propagated = Lutaml::Model::Serialize::DeserializationContext.propagate(options)
+
+      expect(propagated).to be_empty
+    end
+
+    it "CHILD_PROPAGATION_KEYS matches PROPAGATION_KEYS" do
+      expect(Lutaml::Model::Attribute::CHILD_PROPAGATION_KEYS).to eq(propagation_keys)
+    end
+  end
+
+  describe "conditional reference store registration" do
+    it "registers instances by default" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+      end
+
+      obj = klass.new(id: "test")
+      result = Lutaml::Model::Store.resolve(klass, :id, "test")
+      expect(result).to eq(obj)
+    end
+
+    it "skips registration when skip_reference_registration is declared" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+        skip_reference_registration
+      end
+
+      klass.new(id: "test")
+      result = Lutaml::Model::Store.resolve(klass, :id, "test")
+      expect(result).to be_nil
+    end
+
+    it "reference_resolvable? returns true by default" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+      end
+
+      expect(klass.reference_resolvable?).to be true
+    end
+
+    it "reference_resolvable? returns false after skip_reference_registration" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+        skip_reference_registration
+      end
+
+      expect(klass.reference_resolvable?).to be false
+    end
+
+    it "skips registration during allocate_for_deserialization" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+        skip_reference_registration
+      end
+
+      instance = klass.allocate_for_deserialization
+      instance.public_send(:id=, "deserialized")
+      result = Lutaml::Model::Store.resolve(klass, :id, "deserialized")
+      expect(result).to be_nil
+    end
+  end
+
+  describe "class_attributes accessor" do
+    it "returns raw attributes without register merging" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+      end
+
+      expect(klass.class_attributes).to be_a(Hash)
+      expect(klass.class_attributes.keys).to include(:name)
+    end
+  end
+
+  describe "MappingRule#static_namespace_option" do
+    it "returns frozen hash for rules with explicit namespace" do
+      rule = Lutaml::Xml::MappingRule.new(
+        "test",
+        to: :test,
+        namespace: ExampleComNamespace,
+        namespace_set: true,
+      )
+
+      result = rule.static_namespace_option
+      expect(result).to eq({ default_namespace: "http://example.com" })
+      expect(result).to be_frozen
+    end
+
+    it "returns the same object on repeated calls (cached)" do
+      rule = Lutaml::Xml::MappingRule.new(
+        "test",
+        to: :test,
+        namespace: ExampleComNamespace,
+        namespace_set: true,
+      )
+
+      first = rule.static_namespace_option
+      second = rule.static_namespace_option
+      expect(first).to equal(second) # same object identity
+    end
+
+    it "returns nil when no namespace is set" do
+      rule = Lutaml::Xml::MappingRule.new("test", to: :test)
+
+      expect(rule.static_namespace_option).to be_nil
+    end
+
+    it "returns nil when namespace is :inherit" do
+      rule = Lutaml::Xml::MappingRule.new(
+        "test",
+        to: :test,
+        namespace: :inherit,
+      )
+
+      expect(rule.static_namespace_option).to be_nil
+    end
+  end
+
+  describe "String deduplication in namespace URIs" do
+    it "XmlElement#namespace_uri deduplicates via unary minus" do
+      ns_instance = ExampleComNamespace.new
+      parent = Lutaml::Xml::XmlElement.new(nil, {}, [], nil,
+                                           name: "root",
+                                           parent_document: double(namespaces: { nil => ns_instance }))
+      uri = parent.namespace_uri
+
+      # The returned string should be the deduplicated version (-uri)
+      expect(uri).to eq("http://example.com")
+      expect(uri).to be_frozen
+    end
+
+    it "XmlElement#namespaced_name deduplicates the result string" do
+      ExampleComNamespace.new
+      parent = Lutaml::Xml::XmlElement.new(nil, {}, [], nil,
+                                           name: "root",
+                                           default_namespace: "http://example.com",
+                                           parent_document: double(namespaces: {}))
+      result = parent.namespaced_name
+
+      expect(result).to eq("http://example.com:root")
+      expect(result).to be_frozen
+    end
+  end
+
+  describe "value_set_for" do
+    it "transitions from nil (all defaults) to per-attribute tracking" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :age, :integer
+      end
+
+      obj = klass.allocate_for_deserialization
+      expect(obj.using_default?(:name)).to be true
+      expect(obj.using_default?(:age)).to be true
+
+      obj.value_set_for(:name)
+      expect(obj.using_default?(:name)).to be false
+      expect(obj.using_default?(:age)).to be true
+    end
+
+    it "values_set_for sets multiple attributes at once" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :age, :integer
+      end
+
+      obj = klass.allocate_for_deserialization
+      obj.values_set_for(%i[name age])
+
+      expect(obj.using_default?(:name)).to be false
+      expect(obj.using_default?(:age)).to be false
+    end
+  end
+end