persistence 0.0.1.alpha → 0.0.1

data/spec/persistence/cursor/object_and_class_instance_spec.rb

@@ -0,0 +1,73 @@
+
+require_relative '../../../lib/persistence.rb'
+
+describe ::Persistence::Cursor do
+
+  before :all do
+
+    ::Persistence.enable_port( :mock, ::Persistence::Adapter::Mock.new )
+
+    class ::Persistence::Cursor::ClassInstanceMock
+      include ::Persistence
+      attr_non_atomic_accessor :name
+      explicit_index :key
+    end
+
+    @objects = [ ]
+    @index = ::Persistence::Cursor::ClassInstanceMock.index( :key )
+    5.times do |this_number|
+      instance = ::Persistence::Cursor::ClassInstanceMock.new
+      instance.name = 'Number ' << this_number.to_s
+      instance.persist!
+      @index.index_object( instance, instance.name )
+      @index.get_object_id( instance.name ).should == instance.persistence_id
+      @objects.push( instance )
+    end
+
+    @cursor = @index.cursor
+
+  end
+  
+  after :all do
+    ::Persistence.disable_port( :mock )
+  end
+
+  ###########
+  #  count  #
+  ###########
+
+  it 'can count' do
+    ::Persistence::Cursor::ClassInstanceMock.instance_persistence_bucket.count.should == 5
+    ::Persistence::Cursor::ClassInstanceMock.instance_persistence_bucket.count do |object|
+      object == @objects[ 2 ]
+    end.should == 1
+    ::Persistence::Cursor::ClassInstanceMock.instance_persistence_bucket.count( @objects[ 2 ] ).should == 1
+
+    ::Persistence::Cursor::ClassInstanceMock.count.should == 5
+    ::Persistence::Cursor::ClassInstanceMock.count do |object|
+      object == @objects[ 2 ]
+    end.should == 1
+    ::Persistence::Cursor::ClassInstanceMock.count( nil, @objects[ 2 ] ).should == 1
+  end
+
+  ###########
+  #  count  #
+  ###########
+
+  it 'can count' do
+
+    ::Persistence::Cursor::ClassInstanceMock.index( :key ).count.should == 5
+    ::Persistence::Cursor::ClassInstanceMock.index( :key ).count do |object|
+      object == @objects[ 2 ]
+    end.should == 1
+    ::Persistence::Cursor::ClassInstanceMock.index( :key ).count( @objects[ 2 ] ).should == 1
+
+    ::Persistence::Cursor::ClassInstanceMock.count( :key ).should == 5
+    ::Persistence::Cursor::ClassInstanceMock.count( :key ) do |object|
+      object == @objects[ 2 ]
+    end.should == 1
+    ::Persistence::Cursor::ClassInstanceMock.count( :key, @objects[ 2 ] ).should == 1
+  end
+
+end
+

data/spec/persistence/cursor_spec.rb

@@ -0,0 +1,128 @@
+
+require_relative '../../lib/persistence.rb'
+
+describe ::Persistence::Cursor do
+
+  before :all do
+
+    ::Persistence.enable_port( :mock, ::Persistence::Adapter::Mock.new )
+
+    class ::Persistence::Cursor::Mock
+      include ::Persistence
+      attr_non_atomic_accessor :name
+      explicit_index :key
+    end
+
+    @objects = [ ]
+    @index = ::Persistence::Cursor::Mock.index( :key )
+    5.times do |this_number|
+      instance = ::Persistence::Cursor::Mock.new
+      instance.name = 'Number ' << this_number.to_s
+      instance.persist!
+      @index.index_object( instance, instance.name )
+      @index.get_object_id( instance.name ).should == instance.persistence_id
+      @objects.push( instance )
+    end
+
+    @cursor = ::Persistence::Cursor::Mock.instance_persistence_bucket.cursor
+    @index_cursor = @index.cursor
+
+  end
+  
+  after :all do
+    ::Persistence.disable_port( :mock )
+  end
+
+  ################
+  #  persisted?  #
+  ################
+
+  it 'can report whether a key exists and set its position to the key if it does' do
+    @cursor.persisted?( @objects[ 0 ].persistence_id ).should == true
+    @index_cursor.persisted?( @objects[ 0 ].name ).should == true
+  end
+  
+  ###########
+  #  first  #
+  ###########
+  
+  it 'can set its position to the first key' do
+    @cursor.first.should == @objects.first
+    @cursor.first( 2 ).should == @objects.first( 2 )
+    @index_cursor.first.should == @objects.first
+    @index_cursor.first( 2 ).should == @objects.first( 2 )
+  end
+
+  ##########
+  #  last  #
+  ##########
+  
+  it 'can set its position to the last key' do
+    @cursor.last.should == @objects.last
+    @cursor.last( 2 ).should == @objects.last( 2 )
+    @index_cursor.first
+    @index_cursor.current.should == @objects.first
+  end
+
+  #########
+  #  any  #
+  #########
+  
+  it 'can set its position to the last key' do
+    @objects.include?( @cursor.any ).should == true
+    @cursor.any( 2 ).each do |this_object|
+      @objects.include?( this_object ).should == true
+    end
+    @index_cursor.first.should == @objects[ 0 ]
+    @index_cursor.next.should == @objects[ 0 ]
+    @index_cursor.next.should == @objects[ 1 ]
+    @index_cursor.next( 2 ).should == @objects[ 2..3 ]
+  end
+
+  #############
+  #  current  #
+  #############
+  
+  it 'can return the current key' do
+    @cursor.first
+    @cursor.current.should == @objects.first
+  end
+
+  ##########
+  #  next  #
+  ##########
+  
+  it 'can set its position to the next key' do
+    @cursor.first.should == @objects[ 0 ]
+    @cursor.next.should == @objects[ 0 ]
+    @cursor.next.should == @objects[ 1 ]
+    @cursor.next( 2 ).should == @objects[ 2..3 ]
+  end
+
+  ##########
+  #  each  #
+  ##########
+
+  it 'can iterate each record' do
+    @cursor.first
+    @cursor.each_with_index do |this_object, this_index|
+      this_object.should == @objects[ this_index ]
+    end
+    @cursor.first
+    enum = @cursor.each
+    enum.is_a?( Enumerator ).should == true
+    enum.next.should == @objects[ 0 ]
+    enum.next.should == @objects[ 1 ]
+    @index_cursor.first
+    @index_cursor.each_with_index do |this_object, this_index|
+      this_object.should == @objects[ this_index ]
+    end
+    @index_cursor.first
+    enum = @index_cursor.each
+    enum.is_a?( Enumerator ).should == true
+    enum.next.should == @objects[ 0 ]
+    enum.next.should == @objects[ 1 ]
+  end
+
+end
+

data/spec/persistence/object/complex/attributes/persistence_hash/array_instance_spec.rb

@@ -0,0 +1,51 @@
+
+require_relative '../../../../../../lib/persistence.rb'
+
+describe ::Persistence::Object::Complex::Array do
+
+  before :all do
+    ::Persistence.enable_port( :mock, ::Persistence::Adapter::Mock.new )
+  end
+
+  after :all do
+    ::Persistence.disable_port( :mock )
+  end
+
+  ##############################
+  #  persistence_hash_to_port  #
+  ##############################
+
+  it "can create a persistence hash to correspond to persistence state" do
+
+    class ::Persistence::Object::Complex::Array::SubArray < Array
+      include ::Persistence::Object::Complex
+      include ::Persistence::Object::Complex::Array::ObjectInstance
+      extend ::Persistence::Object::Complex::Array::ClassInstance
+    end
+    class ::Persistence::Object::Complex::Array::ComplexObject
+
+      include ::Persistence::Object::Complex
+      
+      def persist!        
+        persistence_port.put_object!( self )
+        return self
+      end
+
+    end
+
+    complex_instance = ::Persistence::Object::Complex::Array::ComplexObject.new
+    instance = ::Persistence::Object::Complex::Array::SubArray.new( [ 1, 2, 3, 4, 5, complex_instance ] )
+    
+    instance.persistence_hash_to_port.should == { 0 => 1,
+                                                  1 => 2,
+                                                  2 => 3,
+                                                  3 => 4,
+                                                  4 => 5,
+                                                  5 => complex_instance.persistence_id.to_s }
+    
+    instance[ 5 ].should == complex_instance
+    instance.instance_eval { is_complex_object?( self [ 5 ] ) }.should == true
+    
+  end
+  
+end

data/spec/persistence/object/complex/attributes/persistence_hash/hash_instance_spec.rb

@@ -0,0 +1,56 @@
+
+require_relative '../../../../../../lib/persistence.rb'
+
+describe ::Persistence::Object::Complex::Hash do
+
+  before :all do
+    ::Persistence.enable_port( :mock, ::Persistence::Adapter::Mock.new )
+  end
+
+  after :all do
+    ::Persistence.disable_port( :mock )
+  end
+
+  ##############################
+  #  persistence_hash_to_port  #
+  ##############################
+
+  it "can create a persistence hash to correspond to persistence state" do
+    module ::Persistence::Object::Complex::Hash::PersistenceHashToPortMock 
+    
+      class HashMock < Hash
+        include ::Persistence::Object::Complex
+        include ::Persistence::Object::Complex::Hash::ObjectInstance
+        extend ::Persistence::Object::Complex::Hash::ClassInstance
+      end
+      
+      class ComplexObject
+
+        include ::Persistence::Object::Complex
+
+        def persist!
+          persistence_port.put_object!( self )
+          return self
+        end
+
+      end
+    
+      complex_instance = ComplexObject.new
+      instance = HashMock.new
+      instance[ 1 ] = :some_value
+      instance[ :key ] = :other_value
+      instance[ complex_instance ] = :complex_value
+      instance[ :complex_key ] = complex_instance
+    
+      instance.persistence_hash_to_port.should == { 1 => :some_value,
+                                                    :key => :other_value,
+                                                    complex_instance.persistence_id.to_s => :complex_value,
+                                                    :complex_key => complex_instance.persistence_id.to_s }
+    
+      instance[ :complex_key ].should == complex_instance
+      instance[ complex_instance ].should == :complex_value
+
+    end
+  end
+
+end

data/spec/persistence/object/complex/attributes_spec.rb

@@ -0,0 +1,1717 @@
+
+require_relative '../../../../lib/persistence.rb'
+
+describe ::Persistence::Object::Complex::Attributes do
+
+  #######################
+  #  atomic_attributes  #
+  #######################
+
+  it 'can declare atomic attribute readers, writers, accessors, and automatically update corresponding declarations' do
+    class ::Persistence::Object::Complex::Attributes::AtomicAttributesMock
+
+      include ::Persistence::Object::Complex
+
+      atomic_attributes.empty?.should == true
+
+      # reader
+      atomic_attributes.add( :some_reader, :reader )
+      atomic_attributes[ :some_reader ].should == :reader
+      persistent_attributes[ :some_reader ].should == :reader
+      atomic_attribute_readers.include?( :some_reader ).should == true
+      atomic_attribute_writers.include?( :some_reader ).should == false
+      atomic_attribute_accessors.include?( :some_reader ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_reader ).should == false
+      non_atomic_attribute_writers.include?( :some_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_reader ).should == false
+
+      atomic_attributes[ :some_other_reader ] = :reader
+      atomic_attributes[ :some_other_reader ].should == :reader
+      persistent_attributes[ :some_other_reader ].should == :reader
+      atomic_attribute_readers.include?( :some_other_reader ).should == true
+      atomic_attribute_writers.include?( :some_other_reader ).should == false
+      atomic_attribute_accessors.include?( :some_other_reader ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_other_reader ).should == false
+      non_atomic_attribute_writers.include?( :some_other_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_other_reader ).should == false
+      
+      atomic_attributes.add( :some_reader, :writer )
+      atomic_attributes[ :some_reader ].should == :accessor
+      persistent_attributes[ :some_reader ].should == :accessor
+      atomic_attribute_readers.include?( :some_reader ).should == true
+      atomic_attribute_writers.include?( :some_reader ).should == true
+      atomic_attribute_accessors.include?( :some_reader ).should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_reader ).should == false
+      non_atomic_attribute_writers.include?( :some_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_reader ).should == false
+
+      atomic_attributes.subtract( :some_reader, :writer )
+      atomic_attributes[ :some_reader ].should == :reader
+      persistent_attributes[ :some_reader ].should == :reader
+      atomic_attribute_readers.include?( :some_reader ).should == true
+      atomic_attribute_writers.include?( :some_reader ).should == false
+      atomic_attribute_accessors.include?( :some_reader ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_reader ).should == false
+      non_atomic_attribute_writers.include?( :some_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_reader ).should == false
+      
+      # writer
+      atomic_attributes.add( :some_writer, :writer )
+      atomic_attributes[ :some_writer ].should == :writer
+      persistent_attributes[ :some_writer ].should == :writer
+      atomic_attribute_readers.include?( :some_writer ).should == false
+      atomic_attribute_writers.include?( :some_writer ).should == true
+      atomic_attribute_accessors.include?( :some_writer ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_writer ).should == false
+      non_atomic_attribute_accessors.include?( :some_writer ).should == false
+
+      atomic_attributes[ :some_other_writer ] = :writer
+      atomic_attributes[ :some_other_writer ].should == :writer
+      persistent_attributes[ :some_other_writer ].should == :writer
+      atomic_attribute_readers.include?( :some_other_writer ).should == false
+      atomic_attribute_writers.include?( :some_other_writer ).should == true
+      atomic_attribute_accessors.include?( :some_other_writer ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_other_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_other_writer ).should == false
+      non_atomic_attribute_accessors.include?( :some_other_writer ).should == false
+      
+      atomic_attributes.add( :some_writer, :reader )
+      atomic_attributes[ :some_writer ].should == :accessor
+      persistent_attributes[ :some_writer ].should == :accessor
+      atomic_attribute_readers.include?( :some_writer ).should == true
+      atomic_attribute_writers.include?( :some_writer ).should == true
+      atomic_attribute_accessors.include?( :some_writer ).should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_writer ).should == false
+      non_atomic_attribute_accessors.include?( :some_writer ).should == false
+      
+      atomic_attributes.subtract( :some_writer, :reader )
+      atomic_attributes[ :some_writer ].should == :writer
+      persistent_attributes[ :some_writer ].should == :writer
+      atomic_attribute_readers.include?( :some_writer ).should == false
+      atomic_attribute_writers.include?( :some_writer ).should == true
+      atomic_attribute_accessors.include?( :some_writer ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_writer ).should == false
+      non_atomic_attribute_accessors.include?( :some_writer ).should == false
+      
+      # accessor
+      atomic_attributes.add( :some_accessor, :accessor )
+      atomic_attributes[ :some_accessor ].should == :accessor
+      persistent_attributes[ :some_accessor ].should == :accessor
+      atomic_attribute_readers.include?( :some_accessor ).should == true
+      atomic_attribute_writers.include?( :some_accessor ).should == true
+      atomic_attribute_accessors.include?( :some_accessor ).should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_accessor ).should == false
+      non_atomic_attribute_writers.include?( :some_accessor ).should == false
+      non_atomic_attribute_accessors.include?( :some_accessor ).should == false
+
+      atomic_attributes[ :some_other_accessor ] = :accessor
+      atomic_attributes[ :some_other_accessor ].should == :accessor
+      persistent_attributes[ :some_other_accessor ].should == :accessor
+      atomic_attribute_readers.include?( :some_other_accessor ).should == true
+      atomic_attribute_writers.include?( :some_other_accessor ).should == true
+      atomic_attribute_accessors.include?( :some_other_accessor ).should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_other_accessor ).should == false
+      non_atomic_attribute_writers.include?( :some_other_accessor ).should == false
+      non_atomic_attribute_accessors.include?( :some_other_accessor ).should == false
+
+      atomic_attributes.subtract( :some_other_accessor, :accessor )
+      atomic_attribute_readers.include?( :some_other_accessor ).should == false
+      atomic_attribute_writers.include?( :some_other_accessor ).should == false
+      atomic_attribute_accessors.include?( :some_other_accessor ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_other_accessor ).should == false
+      non_atomic_attribute_writers.include?( :some_other_accessor ).should == false
+      non_atomic_attribute_accessors.include?( :some_other_accessor ).should == false
+      
+      # nil
+      atomic_attributes[ :some_accessor ] = nil
+      atomic_attribute_readers.include?( :some_accessor ).should == false
+      atomic_attribute_writers.include?( :some_accessor ).should == false
+      atomic_attribute_accessors.include?( :some_accessor ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_accessor ).should == false
+      non_atomic_attribute_writers.include?( :some_accessor ).should == false
+      non_atomic_attribute_accessors.include?( :some_accessor ).should == false
+      
+    end
+  end
+
+  ###########################
+  #  non_atomic_attributes  #
+  ###########################
+
+  it 'can declare non-atomic attribute readers, writers, accessors, and automatically update corresponding declarations' do
+    class ::Persistence::Object::Complex::Attributes::NonAtomicAttributesMock
+
+      include ::Persistence::Object::Complex
+
+      non_atomic_attributes.empty?.should == true
+
+      # reader
+      non_atomic_attributes.add( :some_reader, :reader )
+      non_atomic_attributes[ :some_reader ].should == :reader
+      persistent_attributes[ :some_reader ].should == :reader
+      non_atomic_attribute_readers.include?( :some_reader ).should == true
+      non_atomic_attribute_writers.include?( :some_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_reader ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_reader ).should == false
+      atomic_attribute_writers.include?( :some_reader ).should == false
+      atomic_attribute_accessors.include?( :some_reader ).should == false
+
+      non_atomic_attributes[ :some_other_reader ] = :reader
+      non_atomic_attributes[ :some_other_reader ].should == :reader
+      persistent_attributes[ :some_other_reader ].should == :reader
+      non_atomic_attribute_readers.include?( :some_other_reader ).should == true
+      non_atomic_attribute_writers.include?( :some_other_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_other_reader ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_other_reader ).should == false
+      atomic_attribute_writers.include?( :some_other_reader ).should == false
+      atomic_attribute_accessors.include?( :some_other_reader ).should == false
+      
+      non_atomic_attributes.add( :some_reader, :writer )
+      non_atomic_attributes[ :some_reader ].should == :accessor
+      persistent_attributes[ :some_reader ].should == :accessor
+      non_atomic_attribute_readers.include?( :some_reader ).should == true
+      non_atomic_attribute_writers.include?( :some_reader ).should == true
+      non_atomic_attribute_accessors.include?( :some_reader ).should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_reader ).should == false
+      atomic_attribute_writers.include?( :some_reader ).should == false
+      atomic_attribute_accessors.include?( :some_reader ).should == false
+
+      non_atomic_attributes.subtract( :some_reader, :writer )
+      non_atomic_attributes[ :some_reader ].should == :reader
+      persistent_attributes[ :some_reader ].should == :reader
+      non_atomic_attribute_readers.include?( :some_reader ).should == true
+      non_atomic_attribute_writers.include?( :some_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_reader ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_reader ).should == false
+      atomic_attribute_writers.include?( :some_reader ).should == false
+      atomic_attribute_accessors.include?( :some_reader ).should == false
+      
+      # writer
+      non_atomic_attributes.add( :some_writer, :writer )
+      non_atomic_attributes[ :some_writer ].should == :writer
+      persistent_attributes[ :some_writer ].should == :writer
+      non_atomic_attribute_readers.include?( :some_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_writer ).should == true
+      non_atomic_attribute_accessors.include?( :some_writer ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_writer ).should == false
+      atomic_attribute_writers.include?( :some_writer ).should == false
+      atomic_attribute_accessors.include?( :some_writer ).should == false
+
+      non_atomic_attributes[ :some_other_writer ] = :writer
+      non_atomic_attributes[ :some_other_writer ].should == :writer
+      persistent_attributes[ :some_other_writer ].should == :writer
+      non_atomic_attribute_readers.include?( :some_other_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_other_writer ).should == true
+      non_atomic_attribute_accessors.include?( :some_other_writer ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_other_writer ).should == false
+      atomic_attribute_writers.include?( :some_other_writer ).should == false
+      atomic_attribute_accessors.include?( :some_other_writer ).should == false
+      
+      non_atomic_attributes.add( :some_writer, :reader )
+      non_atomic_attributes[ :some_writer ].should == :accessor
+      persistent_attributes[ :some_writer ].should == :accessor
+      non_atomic_attribute_readers.include?( :some_writer ).should == true
+      non_atomic_attribute_writers.include?( :some_writer ).should == true
+      non_atomic_attribute_accessors.include?( :some_writer ).should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_writer ).should == false
+      atomic_attribute_writers.include?( :some_writer ).should == false
+      atomic_attribute_accessors.include?( :some_writer ).should == false
+      
+      non_atomic_attributes.subtract( :some_writer, :reader )
+      non_atomic_attributes[ :some_writer ].should == :writer
+      persistent_attributes[ :some_writer ].should == :writer
+      non_atomic_attribute_readers.include?( :some_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_writer ).should == true
+      non_atomic_attribute_accessors.include?( :some_writer ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_writer ).should == false
+      atomic_attribute_writers.include?( :some_writer ).should == false
+      atomic_attribute_accessors.include?( :some_writer ).should == false
+      
+      # accessor
+      non_atomic_attributes.add( :some_accessor, :accessor )
+      non_atomic_attributes[ :some_accessor ].should == :accessor
+      persistent_attributes[ :some_accessor ].should == :accessor
+      non_atomic_attribute_readers.include?( :some_accessor ).should == true
+      non_atomic_attribute_writers.include?( :some_accessor ).should == true
+      non_atomic_attribute_accessors.include?( :some_accessor ).should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_accessor ).should == false
+      atomic_attribute_writers.include?( :some_accessor ).should == false
+      atomic_attribute_accessors.include?( :some_accessor ).should == false
+
+      non_atomic_attributes[ :some_other_accessor ] = :accessor
+      non_atomic_attributes[ :some_other_accessor ].should == :accessor
+      persistent_attributes[ :some_other_accessor ].should == :accessor
+      non_atomic_attribute_readers.include?( :some_other_accessor ).should == true
+      non_atomic_attribute_writers.include?( :some_other_accessor ).should == true
+      non_atomic_attribute_accessors.include?( :some_other_accessor ).should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_other_accessor ).should == false
+      atomic_attribute_writers.include?( :some_other_accessor ).should == false
+      atomic_attribute_accessors.include?( :some_other_accessor ).should == false
+
+      non_atomic_attributes.subtract( :some_other_accessor, :accessor )
+      non_atomic_attribute_readers.include?( :some_other_accessor ).should == false
+      non_atomic_attribute_writers.include?( :some_other_accessor ).should == false
+      non_atomic_attribute_accessors.include?( :some_other_accessor ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_other_accessor ).should == false
+      atomic_attribute_writers.include?( :some_other_accessor ).should == false
+      atomic_attribute_accessors.include?( :some_other_accessor ).should == false
+      
+      # nil
+      non_atomic_attributes[ :some_accessor ] = nil
+      non_atomic_attribute_readers.include?( :some_accessor ).should == false
+      non_atomic_attribute_writers.include?( :some_accessor ).should == false
+      non_atomic_attribute_accessors.include?( :some_accessor ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_accessor ).should == false
+      atomic_attribute_writers.include?( :some_accessor ).should == false
+      atomic_attribute_accessors.include?( :some_accessor ).should == false
+      
+    end
+  end
+
+  ###########################
+  #  persistent_attributes  #
+  ###########################
+
+  it 'can declare persistent attribute readers, writers, accessors (which default to non-atomic or atomic), and automatically update corresponding declarations' do
+    class ::Persistence::Object::Complex::Attributes::PersistentAttributesMock
+
+      include ::Persistence::Object::Complex
+
+      # Atomic
+
+      atomic_attributes.empty?.should == true
+      non_atomic_attributes.empty?.should == true
+      persistent_attributes.empty?.should == true
+
+      persistent_attributes.default_atomic!
+
+      # reader
+      persistent_attributes.add( :some_reader, :reader )
+      atomic_attributes[ :some_reader ].should == :reader
+      persistent_attributes[ :some_reader ].should == :reader
+      atomic_attribute_readers.include?( :some_reader ).should == true
+      atomic_attribute_writers.include?( :some_reader ).should == false
+      atomic_attribute_accessors.include?( :some_reader ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_reader ).should == false
+      non_atomic_attribute_writers.include?( :some_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_reader ).should == false
+
+      persistent_attributes[ :some_other_reader ] = :reader
+      atomic_attributes[ :some_other_reader ].should == :reader
+      persistent_attributes[ :some_other_reader ].should == :reader
+      atomic_attribute_readers.include?( :some_other_reader ).should == true
+      atomic_attribute_writers.include?( :some_other_reader ).should == false
+      atomic_attribute_accessors.include?( :some_other_reader ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_other_reader ).should == false
+      non_atomic_attribute_writers.include?( :some_other_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_other_reader ).should == false
+      
+      persistent_attributes.add( :some_reader, :writer )
+      atomic_attributes[ :some_reader ].should == :accessor
+      persistent_attributes[ :some_reader ].should == :accessor
+      atomic_attribute_readers.include?( :some_reader ).should == true
+      atomic_attribute_writers.include?( :some_reader ).should == true
+      atomic_attribute_accessors.include?( :some_reader ).should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_reader ).should == false
+      non_atomic_attribute_writers.include?( :some_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_reader ).should == false
+
+      persistent_attributes.subtract( :some_reader, :writer )
+      atomic_attributes[ :some_reader ].should == :reader
+      persistent_attributes[ :some_reader ].should == :reader
+      atomic_attribute_readers.include?( :some_reader ).should == true
+      atomic_attribute_writers.include?( :some_reader ).should == false
+      atomic_attribute_accessors.include?( :some_reader ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_reader ).should == false
+      non_atomic_attribute_writers.include?( :some_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_reader ).should == false
+      
+      # writer
+      persistent_attributes.add( :some_writer, :writer )
+      atomic_attributes[ :some_writer ].should == :writer
+      persistent_attributes[ :some_writer ].should == :writer
+      atomic_attribute_readers.include?( :some_writer ).should == false
+      atomic_attribute_writers.include?( :some_writer ).should == true
+      atomic_attribute_accessors.include?( :some_writer ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_writer ).should == false
+      non_atomic_attribute_accessors.include?( :some_writer ).should == false
+
+      persistent_attributes[ :some_other_writer ] = :writer
+      atomic_attributes[ :some_other_writer ].should == :writer
+      persistent_attributes[ :some_other_writer ].should == :writer
+      atomic_attribute_readers.include?( :some_other_writer ).should == false
+      atomic_attribute_writers.include?( :some_other_writer ).should == true
+      atomic_attribute_accessors.include?( :some_other_writer ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_other_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_other_writer ).should == false
+      non_atomic_attribute_accessors.include?( :some_other_writer ).should == false
+      
+      persistent_attributes.add( :some_writer, :reader )
+      atomic_attributes[ :some_writer ].should == :accessor
+      persistent_attributes[ :some_writer ].should == :accessor
+      atomic_attribute_readers.include?( :some_writer ).should == true
+      atomic_attribute_writers.include?( :some_writer ).should == true
+      atomic_attribute_accessors.include?( :some_writer ).should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_writer ).should == false
+      non_atomic_attribute_accessors.include?( :some_writer ).should == false
+      
+      persistent_attributes.subtract( :some_writer, :reader )
+      atomic_attributes[ :some_writer ].should == :writer
+      persistent_attributes[ :some_writer ].should == :writer
+      atomic_attribute_readers.include?( :some_writer ).should == false
+      atomic_attribute_writers.include?( :some_writer ).should == true
+      atomic_attribute_accessors.include?( :some_writer ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_writer ).should == false
+      non_atomic_attribute_accessors.include?( :some_writer ).should == false
+      
+      # accessor
+      persistent_attributes.add( :some_accessor, :accessor )
+      atomic_attributes[ :some_accessor ].should == :accessor
+      persistent_attributes[ :some_accessor ].should == :accessor
+      atomic_attribute_readers.include?( :some_accessor ).should == true
+      atomic_attribute_writers.include?( :some_accessor ).should == true
+      atomic_attribute_accessors.include?( :some_accessor ).should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_accessor ).should == false
+      non_atomic_attribute_writers.include?( :some_accessor ).should == false
+      non_atomic_attribute_accessors.include?( :some_accessor ).should == false
+
+      persistent_attributes[ :some_other_accessor ] = :accessor
+      atomic_attributes[ :some_other_accessor ].should == :accessor
+      persistent_attributes[ :some_other_accessor ].should == :accessor
+      atomic_attribute_readers.include?( :some_other_accessor ).should == true
+      atomic_attribute_writers.include?( :some_other_accessor ).should == true
+      atomic_attribute_accessors.include?( :some_other_accessor ).should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_other_accessor ).should == false
+      non_atomic_attribute_writers.include?( :some_other_accessor ).should == false
+      non_atomic_attribute_accessors.include?( :some_other_accessor ).should == false
+
+      persistent_attributes.subtract( :some_other_accessor, :accessor )
+      atomic_attribute_readers.include?( :some_other_accessor ).should == false
+      atomic_attribute_writers.include?( :some_other_accessor ).should == false
+      atomic_attribute_accessors.include?( :some_other_accessor ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_other_accessor ).should == false
+      non_atomic_attribute_writers.include?( :some_other_accessor ).should == false
+      non_atomic_attribute_accessors.include?( :some_other_accessor ).should == false
+      
+      # nil
+      persistent_attributes[ :some_accessor ] = nil
+      atomic_attribute_readers.include?( :some_accessor ).should == false
+      atomic_attribute_writers.include?( :some_accessor ).should == false
+      atomic_attribute_accessors.include?( :some_accessor ).should == false
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_readers.include?( :some_accessor ).should == false
+      non_atomic_attribute_writers.include?( :some_accessor ).should == false
+      non_atomic_attribute_accessors.include?( :some_accessor ).should == false
+
+      atomic_attributes.clear
+      non_atomic_attributes.clear
+      persistent_attributes.clear
+
+      #################################################
+
+      # Non-Atomic
+
+      atomic_attributes.empty?.should == true
+      non_atomic_attributes.empty?.should == true
+      persistent_attributes.empty?.should == true
+
+      persistent_attributes.default_non_atomic!
+
+      # reader
+      persistent_attributes.add( :some_reader, :reader )
+      non_atomic_attributes[ :some_reader ].should == :reader
+      persistent_attributes[ :some_reader ].should == :reader
+      non_atomic_attribute_readers.include?( :some_reader ).should == true
+      non_atomic_attribute_writers.include?( :some_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_reader ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_reader ).should == false
+      atomic_attribute_writers.include?( :some_reader ).should == false
+      atomic_attribute_accessors.include?( :some_reader ).should == false
+
+      persistent_attributes[ :some_other_reader ] = :reader
+      non_atomic_attributes[ :some_other_reader ].should == :reader
+      persistent_attributes[ :some_other_reader ].should == :reader
+      non_atomic_attribute_readers.include?( :some_other_reader ).should == true
+      non_atomic_attribute_writers.include?( :some_other_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_other_reader ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_other_reader ).should == false
+      atomic_attribute_writers.include?( :some_other_reader ).should == false
+      atomic_attribute_accessors.include?( :some_other_reader ).should == false
+      
+      persistent_attributes.add( :some_reader, :writer )
+      non_atomic_attributes[ :some_reader ].should == :accessor
+      persistent_attributes[ :some_reader ].should == :accessor
+      non_atomic_attribute_readers.include?( :some_reader ).should == true
+      non_atomic_attribute_writers.include?( :some_reader ).should == true
+      non_atomic_attribute_accessors.include?( :some_reader ).should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_reader ).should == false
+      atomic_attribute_writers.include?( :some_reader ).should == false
+      atomic_attribute_accessors.include?( :some_reader ).should == false
+
+      persistent_attributes.subtract( :some_reader, :writer )
+      non_atomic_attributes[ :some_reader ].should == :reader
+      persistent_attributes[ :some_reader ].should == :reader
+      non_atomic_attribute_readers.include?( :some_reader ).should == true
+      non_atomic_attribute_writers.include?( :some_reader ).should == false
+      non_atomic_attribute_accessors.include?( :some_reader ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_reader ).should == false
+      atomic_attribute_writers.include?( :some_reader ).should == false
+      atomic_attribute_accessors.include?( :some_reader ).should == false
+      
+      # writer
+      persistent_attributes.add( :some_writer, :writer )
+      non_atomic_attributes[ :some_writer ].should == :writer
+      persistent_attributes[ :some_writer ].should == :writer
+      non_atomic_attribute_readers.include?( :some_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_writer ).should == true
+      non_atomic_attribute_accessors.include?( :some_writer ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_writer ).should == false
+      atomic_attribute_writers.include?( :some_writer ).should == false
+      atomic_attribute_accessors.include?( :some_writer ).should == false
+
+      persistent_attributes[ :some_other_writer ] = :writer
+      non_atomic_attributes[ :some_other_writer ].should == :writer
+      persistent_attributes[ :some_other_writer ].should == :writer
+      non_atomic_attribute_readers.include?( :some_other_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_other_writer ).should == true
+      non_atomic_attribute_accessors.include?( :some_other_writer ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_other_writer ).should == false
+      atomic_attribute_writers.include?( :some_other_writer ).should == false
+      atomic_attribute_accessors.include?( :some_other_writer ).should == false
+      
+      persistent_attributes.add( :some_writer, :reader )
+      non_atomic_attributes[ :some_writer ].should == :accessor
+      persistent_attributes[ :some_writer ].should == :accessor
+      non_atomic_attribute_readers.include?( :some_writer ).should == true
+      non_atomic_attribute_writers.include?( :some_writer ).should == true
+      non_atomic_attribute_accessors.include?( :some_writer ).should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_writer ).should == false
+      atomic_attribute_writers.include?( :some_writer ).should == false
+      atomic_attribute_accessors.include?( :some_writer ).should == false
+      
+      persistent_attributes.subtract( :some_writer, :reader )
+      non_atomic_attributes[ :some_writer ].should == :writer
+      persistent_attributes[ :some_writer ].should == :writer
+      non_atomic_attribute_readers.include?( :some_writer ).should == false
+      non_atomic_attribute_writers.include?( :some_writer ).should == true
+      non_atomic_attribute_accessors.include?( :some_writer ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_writer ).should == false
+      atomic_attribute_writers.include?( :some_writer ).should == false
+      atomic_attribute_accessors.include?( :some_writer ).should == false
+      
+      # accessor
+      persistent_attributes.add( :some_accessor, :accessor )
+      non_atomic_attributes[ :some_accessor ].should == :accessor
+      persistent_attributes[ :some_accessor ].should == :accessor
+      non_atomic_attribute_readers.include?( :some_accessor ).should == true
+      non_atomic_attribute_writers.include?( :some_accessor ).should == true
+      non_atomic_attribute_accessors.include?( :some_accessor ).should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_accessor ).should == false
+      atomic_attribute_writers.include?( :some_accessor ).should == false
+      atomic_attribute_accessors.include?( :some_accessor ).should == false
+
+      persistent_attributes[ :some_other_accessor ] = :accessor
+      non_atomic_attributes[ :some_other_accessor ].should == :accessor
+      persistent_attributes[ :some_other_accessor ].should == :accessor
+      non_atomic_attribute_readers.include?( :some_other_accessor ).should == true
+      non_atomic_attribute_writers.include?( :some_other_accessor ).should == true
+      non_atomic_attribute_accessors.include?( :some_other_accessor ).should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_other_accessor ).should == false
+      atomic_attribute_writers.include?( :some_other_accessor ).should == false
+      atomic_attribute_accessors.include?( :some_other_accessor ).should == false
+
+      persistent_attributes.subtract( :some_other_accessor, :accessor )
+      non_atomic_attribute_readers.include?( :some_other_accessor ).should == false
+      non_atomic_attribute_writers.include?( :some_other_accessor ).should == false
+      non_atomic_attribute_accessors.include?( :some_other_accessor ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_other_accessor ).should == false
+      atomic_attribute_writers.include?( :some_other_accessor ).should == false
+      atomic_attribute_accessors.include?( :some_other_accessor ).should == false
+      
+      # nil
+      persistent_attributes[ :some_accessor ] = nil
+      non_atomic_attribute_readers.include?( :some_accessor ).should == false
+      non_atomic_attribute_writers.include?( :some_accessor ).should == false
+      non_atomic_attribute_accessors.include?( :some_accessor ).should == false
+      atomic_attributes.empty?.should == true
+      atomic_attribute_readers.include?( :some_accessor ).should == false
+      atomic_attribute_writers.include?( :some_accessor ).should == false
+      atomic_attribute_accessors.include?( :some_accessor ).should == false
+      
+    end
+  end
+
+  ##############################
+  #  atomic_attribute_readers  #
+  ##############################
+
+  it 'can declare atomic attribute accessors' do
+    class ::Persistence::Object::Complex::Attributes::AtomicAttributeReaders
+
+      include ::Persistence::Object::Complex
+
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+      atomic_attributes.empty?.should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+
+      atomic_attribute_readers.push( :some_reader )
+      atomic_attributes[ :some_reader ].should == :reader
+      persistent_attributes[ :some_reader ].should == :reader
+      atomic_attribute_readers.should == [ :some_reader ]
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true      
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+
+      atomic_attributes[ :some_reader ] = :accessor
+      atomic_attribute_writers.delete( :some_reader )
+      atomic_attribute_readers.should == [ :some_reader ]
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true      
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+      
+      atomic_attribute_readers.delete( :some_reader )
+      atomic_attributes[ :some_reader ].should == nil
+      persistent_attributes[ :some_reader ].should == nil
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true      
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+      
+    end
+  end
+
+
+  ##############################
+  #  atomic_attribute_writers  #
+  ##############################
+
+  it 'can declare atomic attribute accessors' do
+    class ::Persistence::Object::Complex::Attributes::AtomicAttributeWriters
+
+      include ::Persistence::Object::Complex
+
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+      atomic_attributes.empty?.should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+
+      atomic_attribute_writers.push( :some_writer )
+      atomic_attributes[ :some_writer ].should == :writer
+      persistent_attributes[ :some_writer ].should == :writer
+      atomic_attribute_writers.should == [ :some_writer ]
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true      
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+    
+      atomic_attributes[ :some_writer ] = :accessor
+      atomic_attribute_readers.delete( :some_writer )
+      atomic_attribute_writers.should == [ :some_writer ]
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true      
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+    
+      atomic_attribute_writers.delete( :some_writer )
+      atomic_attributes[ :some_writer ].should == nil
+      persistent_attributes[ :some_writer ].should == nil
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true      
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+    
+    end
+  end
+
+  ################################
+  #  atomic_attribute_accessors  #
+  ################################
+
+  it 'can declare atomic attribute accessors' do
+    class ::Persistence::Object::Complex::Attributes::AtomicAttributeAccessors
+
+      include ::Persistence::Object::Complex
+
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+      atomic_attributes.empty?.should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+
+      atomic_attribute_accessors.push( :some_accessor )
+      atomic_attributes[ :some_accessor ].should == :accessor
+      persistent_attributes[ :some_accessor ].should == :accessor
+      atomic_attribute_writers.should == [ :some_accessor ]
+      atomic_attribute_readers.should == [ :some_accessor ]
+      atomic_attribute_accessors.should == [ :some_accessor ]
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+    
+      atomic_attribute_accessors.delete( :some_accessor )
+      atomic_attributes[ :some_accessor ].should == nil
+      persistent_attributes[ :some_accessor ].should == nil
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true      
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+    
+    end
+  end
+
+  ##################################
+  #  non_atomic_attribute_readers  #
+  ##################################
+
+  it 'can declare non-atomic attribute accessors' do
+    class ::Persistence::Object::Complex::Attributes::NonAtomicAttributeReaders
+
+      include ::Persistence::Object::Complex
+
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+      non_atomic_attributes.empty?.should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+
+      non_atomic_attribute_readers.push( :some_reader )
+      non_atomic_attributes[ :some_reader ].should == :reader
+      persistent_attributes[ :some_reader ].should == :reader
+      non_atomic_attribute_readers.should == [ :some_reader ]
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true      
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+
+      non_atomic_attributes[ :some_reader ] = :accessor
+      non_atomic_attribute_writers.delete( :some_reader )
+      non_atomic_attribute_readers.should == [ :some_reader ]
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true      
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+      
+      non_atomic_attribute_readers.delete( :some_reader )
+      non_atomic_attributes[ :some_reader ].should == nil
+      persistent_attributes[ :some_reader ].should == nil
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true      
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+      
+    end
+  end
+
+  ##################################
+  #  non_atomic_attribute_writers  #
+  ##################################
+
+  it 'can declare non-atomic attribute accessors' do
+    class ::Persistence::Object::Complex::Attributes::NonAtomicAttributeWriters
+
+      include ::Persistence::Object::Complex
+
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+      non_atomic_attributes.empty?.should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+
+      non_atomic_attribute_writers.push( :some_writer )
+      non_atomic_attributes[ :some_writer ].should == :writer
+      persistent_attributes[ :some_writer ].should == :writer
+      non_atomic_attribute_writers.should == [ :some_writer ]
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true      
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+    
+      non_atomic_attributes[ :some_writer ] = :accessor
+      non_atomic_attribute_readers.delete( :some_writer )
+      non_atomic_attribute_writers.should == [ :some_writer ]
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true      
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+    
+      non_atomic_attribute_writers.delete( :some_writer )
+      non_atomic_attributes[ :some_writer ].should == nil
+      persistent_attributes[ :some_writer ].should == nil
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true      
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+    
+    end
+  end
+
+  ####################################
+  #  non_atomic_attribute_accessors  #
+  ####################################
+
+  it 'can declare non-atomic attribute accessors' do
+    class ::Persistence::Object::Complex::Attributes::NonAtomicAttributeAccessors
+
+      include ::Persistence::Object::Complex
+
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+      non_atomic_attributes.empty?.should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+
+      non_atomic_attribute_accessors.push( :some_accessor )
+      non_atomic_attributes[ :some_accessor ].should == :accessor
+      persistent_attributes[ :some_accessor ].should == :accessor
+      non_atomic_attribute_writers.should == [ :some_accessor ]
+      non_atomic_attribute_readers.should == [ :some_accessor ]
+      non_atomic_attribute_accessors.should == [ :some_accessor ]
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+    
+      non_atomic_attribute_accessors.delete( :some_accessor )
+      non_atomic_attributes[ :some_accessor ].should == nil
+      persistent_attributes[ :some_accessor ].should == nil
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true      
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+    
+    end
+  end
+
+  ##################################
+  #  persistent_attribute_readers  #
+  ##################################
+
+  it 'can declare persistent attribute readers' do
+    class ::Persistence::Object::Complex::Attributes::PersistentAttributeReaders
+
+      include ::Persistence::Object::Complex
+      
+        # Atomic
+        
+        persistent_attribute_readers.default_atomic!
+        
+        atomic_attribute_writers.empty?.should == true
+        atomic_attribute_readers.empty?.should == true
+        atomic_attribute_accessors.empty?.should == true
+        atomic_attributes.empty?.should == true
+        non_atomic_attributes.empty?.should == true
+        non_atomic_attribute_writers.empty?.should == true
+        non_atomic_attribute_readers.empty?.should == true
+        non_atomic_attribute_accessors.empty?.should == true
+
+        atomic_attribute_readers.push( :some_reader )
+        atomic_attributes[ :some_reader ].should == :reader
+        persistent_attributes[ :some_reader ].should == :reader
+        atomic_attribute_readers.should == [ :some_reader ]
+        atomic_attribute_writers.empty?.should == true
+        atomic_attribute_accessors.empty?.should == true      
+        non_atomic_attributes.empty?.should == true
+        non_atomic_attribute_writers.empty?.should == true
+        non_atomic_attribute_readers.empty?.should == true
+        non_atomic_attribute_accessors.empty?.should == true
+
+        atomic_attributes[ :some_reader ] = :accessor
+        atomic_attribute_writers.delete( :some_reader )
+        atomic_attribute_readers.should == [ :some_reader ]
+        atomic_attribute_writers.empty?.should == true
+        atomic_attribute_accessors.empty?.should == true      
+        non_atomic_attributes.empty?.should == true
+        non_atomic_attribute_writers.empty?.should == true
+        non_atomic_attribute_readers.empty?.should == true
+        non_atomic_attribute_accessors.empty?.should == true
+
+        atomic_attribute_readers.delete( :some_reader )
+        atomic_attributes[ :some_reader ].should == nil
+        persistent_attributes[ :some_reader ].should == nil
+        atomic_attribute_readers.empty?.should == true
+        atomic_attribute_writers.empty?.should == true
+        atomic_attribute_accessors.empty?.should == true      
+        non_atomic_attributes.empty?.should == true
+        non_atomic_attribute_writers.empty?.should == true
+        non_atomic_attribute_readers.empty?.should == true
+        non_atomic_attribute_accessors.empty?.should == true
+        
+        # Non-Atomic
+        
+        persistent_attribute_readers.default_non_atomic!
+        
+        non_atomic_attribute_writers.empty?.should == true
+        non_atomic_attribute_readers.empty?.should == true
+        non_atomic_attribute_accessors.empty?.should == true
+        non_atomic_attributes.empty?.should == true
+        atomic_attributes.empty?.should == true
+        atomic_attribute_writers.empty?.should == true
+        atomic_attribute_readers.empty?.should == true
+        atomic_attribute_accessors.empty?.should == true
+
+        non_atomic_attribute_readers.push( :some_reader )
+        non_atomic_attributes[ :some_reader ].should == :reader
+        persistent_attributes[ :some_reader ].should == :reader
+        non_atomic_attribute_readers.should == [ :some_reader ]
+        non_atomic_attribute_writers.empty?.should == true
+        non_atomic_attribute_accessors.empty?.should == true      
+        atomic_attributes.empty?.should == true
+        atomic_attribute_writers.empty?.should == true
+        atomic_attribute_readers.empty?.should == true
+        atomic_attribute_accessors.empty?.should == true
+
+        non_atomic_attributes[ :some_reader ] = :accessor
+        non_atomic_attribute_writers.delete( :some_reader )
+        non_atomic_attribute_readers.should == [ :some_reader ]
+        non_atomic_attribute_writers.empty?.should == true
+        non_atomic_attribute_accessors.empty?.should == true      
+        atomic_attributes.empty?.should == true
+        atomic_attribute_writers.empty?.should == true
+        atomic_attribute_readers.empty?.should == true
+        atomic_attribute_accessors.empty?.should == true
+
+        non_atomic_attribute_readers.delete( :some_reader )
+        non_atomic_attributes[ :some_reader ].should == nil
+        persistent_attributes[ :some_reader ].should == nil
+        non_atomic_attribute_readers.empty?.should == true
+        non_atomic_attribute_writers.empty?.should == true
+        non_atomic_attribute_accessors.empty?.should == true      
+        atomic_attributes.empty?.should == true
+        atomic_attribute_writers.empty?.should == true
+        atomic_attribute_readers.empty?.should == true
+        atomic_attribute_accessors.empty?.should == true
+        
+    end
+  end
+
+  ##################################
+  #  persistent_attribute_writers  #
+  ##################################
+
+  it 'can declare persistent attribute writers' do
+    class ::Persistence::Object::Complex::Attributes::PersistentAttributeWriters
+
+      include ::Persistence::Object::Complex
+
+      # Atomic
+      
+      persistent_attribute_writers.default_atomic!
+      
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+      atomic_attributes.empty?.should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+
+      atomic_attribute_writers.push( :some_writer )
+      atomic_attributes[ :some_writer ].should == :writer
+      persistent_attributes[ :some_writer ].should == :writer
+      atomic_attribute_writers.should == [ :some_writer ]
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true      
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+    
+      atomic_attributes[ :some_writer ] = :accessor
+      atomic_attribute_readers.delete( :some_writer )
+      atomic_attribute_writers.should == [ :some_writer ]
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true      
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+    
+      atomic_attribute_writers.delete( :some_writer )
+      atomic_attributes[ :some_writer ].should == nil
+      persistent_attributes[ :some_writer ].should == nil
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true      
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+      
+      # Non-Atomic
+      
+      persistent_attribute_writers.default_non_atomic!
+
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+      non_atomic_attributes.empty?.should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+
+      non_atomic_attribute_writers.push( :some_writer )
+      non_atomic_attributes[ :some_writer ].should == :writer
+      persistent_attributes[ :some_writer ].should == :writer
+      non_atomic_attribute_writers.should == [ :some_writer ]
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true      
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+    
+      non_atomic_attributes[ :some_writer ] = :accessor
+      non_atomic_attribute_readers.delete( :some_writer )
+      non_atomic_attribute_writers.should == [ :some_writer ]
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true      
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+    
+      non_atomic_attribute_writers.delete( :some_writer )
+      non_atomic_attributes[ :some_writer ].should == nil
+      persistent_attributes[ :some_writer ].should == nil
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true      
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+      
+    end
+  end
+
+  ####################################
+  #  persistent_attribute_accessors  #
+  ####################################
+
+  it 'can declare persistent attribute accessors' do
+    class ::Persistence::Object::Complex::Attributes::PersistentAttributeAccessors
+
+      include ::Persistence::Object::Complex
+
+      # Atomic
+      
+      persistent_attribute_accessors.default_atomic!
+      
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+      atomic_attributes.empty?.should == true
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+
+      atomic_attribute_accessors.push( :some_accessor )
+      atomic_attributes[ :some_accessor ].should == :accessor
+      persistent_attributes[ :some_accessor ].should == :accessor
+      atomic_attribute_writers.should == [ :some_accessor ]
+      atomic_attribute_readers.should == [ :some_accessor ]
+      atomic_attribute_accessors.should == [ :some_accessor ]
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+    
+      atomic_attribute_accessors.delete( :some_accessor )
+      atomic_attributes[ :some_accessor ].should == nil
+      persistent_attributes[ :some_accessor ].should == nil
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true      
+      non_atomic_attributes.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+      
+      
+      # Non-Atomic
+      
+      persistent_attribute_accessors.default_non_atomic!
+      
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true
+      non_atomic_attributes.empty?.should == true
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+
+      non_atomic_attribute_accessors.push( :some_accessor )
+      non_atomic_attributes[ :some_accessor ].should == :accessor
+      persistent_attributes[ :some_accessor ].should == :accessor
+      non_atomic_attribute_writers.should == [ :some_accessor ]
+      non_atomic_attribute_readers.should == [ :some_accessor ]
+      non_atomic_attribute_accessors.should == [ :some_accessor ]
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+    
+      non_atomic_attribute_accessors.delete( :some_accessor )
+      non_atomic_attributes[ :some_accessor ].should == nil
+      persistent_attributes[ :some_accessor ].should == nil
+      non_atomic_attribute_readers.empty?.should == true
+      non_atomic_attribute_writers.empty?.should == true
+      non_atomic_attribute_accessors.empty?.should == true      
+      atomic_attributes.empty?.should == true
+      atomic_attribute_writers.empty?.should == true
+      atomic_attribute_readers.empty?.should == true
+      atomic_attribute_accessors.empty?.should == true
+      
+    end
+  end
+
+  #######################
+  #  atomic_attribute?  #
+  #######################
+  
+  it 'can report whether an attribute is atomic (:accessor, :reader, :writer).' do
+    class ::Persistence::Object::Complex::Attributes::AtomicAttributeQ
+      include ::Persistence::Object::Complex
+      atomic_attributes[ :some_accessor ] = :accessor
+      atomic_attributes[ :some_reader ] = :reader
+      atomic_attributes[ :some_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::AtomicAttributeQ.new.instance_eval do
+
+      atomic_attribute?( :some_accessor ).should == true
+      atomic_attribute?( :some_reader ).should == true
+      atomic_attribute?( :some_writer ).should == true
+      atomic_attribute?( :some_other_accessor ).should == false
+      atomic_attribute?( :some_other_reader ).should == false
+      atomic_attribute?( :some_other_writer ).should == false
+
+      atomic_attribute?( :some_accessor ).should == true
+      atomic_attribute?( :some_reader ).should == true
+      atomic_attribute?( :some_writer ).should == true
+      atomic_attribute?( :some_other_accessor ).should == false
+      atomic_attribute?( :some_other_reader ).should == false
+      atomic_attribute?( :some_other_writer ).should == false
+
+    end
+  end
+
+  ################################
+  #  atomic_attribute_accessor?  #
+  ################################
+  
+  it 'can report whether an attribute is a atomic :accessor' do
+    class ::Persistence::Object::Complex::Attributes::AtomicAttributeAccessorQ
+      include ::Persistence::Object::Complex
+      atomic_attributes[ :some_accessor ] = :accessor
+      atomic_attributes[ :some_reader ] = :reader
+      atomic_attributes[ :some_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::AtomicAttributeAccessorQ.new.instance_eval do
+
+      atomic_attribute_accessor?( :some_accessor ).should == true
+      atomic_attribute_accessor?( :some_reader ).should == false
+      atomic_attribute_accessor?( :some_writer ).should == false
+      atomic_attribute_accessor?( :some_other_accessor ).should == false
+      atomic_attribute_accessor?( :some_other_reader ).should == false
+      atomic_attribute_accessor?( :some_other_writer ).should == false
+
+      atomic_attribute_accessor?( :some_accessor ).should == true
+      atomic_attribute_accessor?( :some_reader ).should == false
+      atomic_attribute_accessor?( :some_writer ).should == false
+      atomic_attribute_accessor?( :some_other_accessor ).should == false
+      atomic_attribute_accessor?( :some_other_reader ).should == false
+      atomic_attribute_accessor?( :some_other_writer ).should == false
+
+    end
+  end
+
+  ##############################
+  #  atomic_attribute_reader?  #
+  ##############################
+  
+  it 'can report whether an attribute is a atomic :reader' do
+    class ::Persistence::Object::Complex::Attributes::AtomicAttributeReaderQ
+      include ::Persistence::Object::Complex
+      atomic_attributes[ :some_accessor ] = :accessor
+      atomic_attributes[ :some_reader ] = :reader
+      atomic_attributes[ :some_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::AtomicAttributeReaderQ.new.instance_eval do
+
+      atomic_attribute_reader?( :some_accessor ).should == true
+      atomic_attribute_reader?( :some_reader ).should == true
+      atomic_attribute_reader?( :some_writer ).should == false
+      atomic_attribute_reader?( :some_other_accessor ).should == false
+      atomic_attribute_reader?( :some_other_reader ).should == false
+      atomic_attribute_reader?( :some_other_writer ).should == false
+
+      atomic_attribute_reader?( :some_accessor ).should == true
+      atomic_attribute_reader?( :some_reader ).should == true
+      atomic_attribute_reader?( :some_writer ).should == false
+      atomic_attribute_reader?( :some_other_accessor ).should == false
+      atomic_attribute_reader?( :some_other_reader ).should == false
+      atomic_attribute_reader?( :some_other_writer ).should == false
+
+    end
+  end
+
+  ##############################
+  #  atomic_attribute_writer?  #
+  ##############################
+  
+  it 'can report whether an attribute is a atomic :writer' do
+    class ::Persistence::Object::Complex::Attributes::AtomicAttributeWriterQ
+      include ::Persistence::Object::Complex
+      atomic_attributes[ :some_accessor ] = :accessor
+      atomic_attributes[ :some_reader ] = :reader
+      atomic_attributes[ :some_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::AtomicAttributeWriterQ.new.instance_eval do
+
+      atomic_attribute_writer?( :some_accessor ).should == true
+      atomic_attribute_writer?( :some_reader ).should == false
+      atomic_attribute_writer?( :some_writer ).should == true
+      atomic_attribute_writer?( :some_other_accessor ).should == false
+      atomic_attribute_writer?( :some_other_reader ).should == false
+      atomic_attribute_writer?( :some_other_writer ).should == false
+
+      atomic_attribute_writer?( :some_accessor ).should == true
+      atomic_attribute_writer?( :some_reader ).should == false
+      atomic_attribute_writer?( :some_writer ).should == true
+      atomic_attribute_writer?( :some_other_accessor ).should == false
+      atomic_attribute_writer?( :some_other_reader ).should == false
+      atomic_attribute_writer?( :some_other_writer ).should == false
+
+    end
+  end
+
+  #############################
+  #  atomic_attribute_status  #
+  #############################
+  
+  it 'can report the current atomic status (:accessor, :reader, :writer) of an attribute' do
+    class ::Persistence::Object::Complex::Attributes::AtomicAttributeStatus
+      include ::Persistence::Object::Complex
+      atomic_attributes[ :some_accessor ] = :accessor
+      atomic_attributes[ :some_reader ] = :reader
+      atomic_attributes[ :some_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::AtomicAttributeStatus.new.instance_eval do
+
+      atomic_attribute_status( :some_accessor ).should == :accessor
+      atomic_attribute_status( :some_reader ).should == :reader
+      atomic_attribute_status( :some_writer ).should == :writer
+      atomic_attribute_status( :some_other_accessor ).should == nil
+      atomic_attribute_status( :some_other_reader ).should == nil
+      atomic_attribute_status( :some_other_writer ).should == nil
+
+      atomic_attribute_status( :some_accessor ).should == :accessor
+      atomic_attribute_status( :some_reader ).should == :reader
+      atomic_attribute_status( :some_writer ).should == :writer
+      atomic_attribute_status( :some_other_accessor ).should == nil
+      atomic_attribute_status( :some_other_reader ).should == nil
+      atomic_attribute_status( :some_other_writer ).should == nil
+
+    end
+  end
+
+  ###########################
+  #  non_atomic_attribute?  #
+  ###########################
+  
+  it 'can report whether an attribute is non_atomic (:accessor, :reader, :writer).' do
+    class ::Persistence::Object::Complex::Attributes::NonAtomicAttributeQ
+      include ::Persistence::Object::Complex
+      non_atomic_attributes[ :some_accessor ] = :accessor
+      non_atomic_attributes[ :some_reader ] = :reader
+      non_atomic_attributes[ :some_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::NonAtomicAttributeQ.new.instance_eval do
+
+      non_atomic_attribute?( :some_accessor ).should == true
+      non_atomic_attribute?( :some_reader ).should == true
+      non_atomic_attribute?( :some_writer ).should == true
+      non_atomic_attribute?( :some_other_accessor ).should == false
+      non_atomic_attribute?( :some_other_reader ).should == false
+      non_atomic_attribute?( :some_other_writer ).should == false
+
+      non_atomic_attribute?( :some_accessor ).should == true
+      non_atomic_attribute?( :some_reader ).should == true
+      non_atomic_attribute?( :some_writer ).should == true
+      non_atomic_attribute?( :some_other_accessor ).should == false
+      non_atomic_attribute?( :some_other_reader ).should == false
+      non_atomic_attribute?( :some_other_writer ).should == false
+
+    end
+  end
+
+  ####################################
+  #  non_atomic_attribute_accessor?  #
+  ####################################
+  
+  it 'can report whether an attribute is a non_atomic :accessor' do
+    class ::Persistence::Object::Complex::Attributes::NonAtomicAttributeAccessorQ
+      include ::Persistence::Object::Complex
+      non_atomic_attributes[ :some_accessor ] = :accessor
+      non_atomic_attributes[ :some_reader ] = :reader
+      non_atomic_attributes[ :some_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::NonAtomicAttributeAccessorQ.new.instance_eval do
+
+      non_atomic_attribute_accessor?( :some_accessor ).should == true
+      non_atomic_attribute_accessor?( :some_reader ).should == false
+      non_atomic_attribute_accessor?( :some_writer ).should == false
+      non_atomic_attribute_accessor?( :some_other_accessor ).should == false
+      non_atomic_attribute_accessor?( :some_other_reader ).should == false
+      non_atomic_attribute_accessor?( :some_other_writer ).should == false
+
+      non_atomic_attribute_accessor?( :some_accessor ).should == true
+      non_atomic_attribute_accessor?( :some_reader ).should == false
+      non_atomic_attribute_accessor?( :some_writer ).should == false
+      non_atomic_attribute_accessor?( :some_other_accessor ).should == false
+      non_atomic_attribute_accessor?( :some_other_reader ).should == false
+      non_atomic_attribute_accessor?( :some_other_writer ).should == false
+
+    end
+  end
+
+  ##################################
+  #  non_atomic_attribute_reader?  #
+  ##################################
+  
+  it 'can report whether an attribute is a non_atomic :reader' do
+    class ::Persistence::Object::Complex::Attributes::NonAtomicAttributeReaderQ
+      include ::Persistence::Object::Complex
+      non_atomic_attributes[ :some_accessor ] = :accessor
+      non_atomic_attributes[ :some_reader ] = :reader
+      non_atomic_attributes[ :some_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::NonAtomicAttributeReaderQ.new.instance_eval do
+
+      non_atomic_attribute_reader?( :some_accessor ).should == true
+      non_atomic_attribute_reader?( :some_reader ).should == true
+      non_atomic_attribute_reader?( :some_writer ).should == false
+      non_atomic_attribute_reader?( :some_other_accessor ).should == false
+      non_atomic_attribute_reader?( :some_other_reader ).should == false
+      non_atomic_attribute_reader?( :some_other_writer ).should == false
+
+      non_atomic_attribute_reader?( :some_accessor ).should == true
+      non_atomic_attribute_reader?( :some_reader ).should == true
+      non_atomic_attribute_reader?( :some_writer ).should == false
+      non_atomic_attribute_reader?( :some_other_accessor ).should == false
+      non_atomic_attribute_reader?( :some_other_reader ).should == false
+      non_atomic_attribute_reader?( :some_other_writer ).should == false
+
+    end
+  end
+
+  ##################################
+  #  non_atomic_attribute_writer?  #
+  ##################################
+  
+  it 'can report whether an attribute is a non_atomic :writer' do
+    class ::Persistence::Object::Complex::Attributes::NonAtomicAttributeWriterQ
+      include ::Persistence::Object::Complex
+      non_atomic_attributes[ :some_accessor ] = :accessor
+      non_atomic_attributes[ :some_reader ] = :reader
+      non_atomic_attributes[ :some_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::NonAtomicAttributeWriterQ.new.instance_eval do
+
+      non_atomic_attribute_writer?( :some_accessor ).should == true
+      non_atomic_attribute_writer?( :some_reader ).should == false
+      non_atomic_attribute_writer?( :some_writer ).should == true
+      non_atomic_attribute_writer?( :some_other_accessor ).should == false
+      non_atomic_attribute_writer?( :some_other_reader ).should == false
+      non_atomic_attribute_writer?( :some_other_writer ).should == false
+
+      non_atomic_attribute_writer?( :some_accessor ).should == true
+      non_atomic_attribute_writer?( :some_reader ).should == false
+      non_atomic_attribute_writer?( :some_writer ).should == true
+      non_atomic_attribute_writer?( :some_other_accessor ).should == false
+      non_atomic_attribute_writer?( :some_other_reader ).should == false
+      non_atomic_attribute_writer?( :some_other_writer ).should == false
+
+    end
+  end
+
+  #################################
+  #  non_atomic_attribute_status  #
+  #################################
+  
+  it 'can report the current non_atomic status (:accessor, :reader, :writer) of an attribute' do
+    class ::Persistence::Object::Complex::Attributes::NonAtomicAttributeStatus
+      include ::Persistence::Object::Complex
+      non_atomic_attributes[ :some_accessor ] = :accessor
+      non_atomic_attributes[ :some_reader ] = :reader
+      non_atomic_attributes[ :some_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::NonAtomicAttributeStatus.new.instance_eval do
+
+      non_atomic_attribute_status( :some_accessor ).should == :accessor
+      non_atomic_attribute_status( :some_reader ).should == :reader
+      non_atomic_attribute_status( :some_writer ).should == :writer
+      non_atomic_attribute_status( :some_other_accessor ).should == nil
+      non_atomic_attribute_status( :some_other_reader ).should == nil
+      non_atomic_attribute_status( :some_other_writer ).should == nil
+
+      non_atomic_attribute_status( :some_accessor ).should == :accessor
+      non_atomic_attribute_status( :some_reader ).should == :reader
+      non_atomic_attribute_status( :some_writer ).should == :writer
+      non_atomic_attribute_status( :some_other_accessor ).should == nil
+      non_atomic_attribute_status( :some_other_reader ).should == nil
+      non_atomic_attribute_status( :some_other_writer ).should == nil
+
+    end
+  end
+
+  ###########################
+  #  persistent_attribute?  #
+  ###########################
+  
+  it 'can report whether an attribute is persistent (:accessor, :reader, :writer).' do
+    class ::Persistence::Object::Complex::Attributes::PersistentAttributeQ
+      include ::Persistence::Object::Complex
+      non_atomic_attributes[ :some_non_atomic_accessor ] = :accessor
+      non_atomic_attributes[ :some_non_atomic_reader ] = :reader
+      non_atomic_attributes[ :some_non_atomic_writer ] = :writer
+      atomic_attributes[ :some_atomic_accessor ] = :accessor
+      atomic_attributes[ :some_atomic_reader ] = :reader
+      atomic_attributes[ :some_atomic_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::PersistentAttributeQ.new.instance_eval do
+
+      persistent_attribute?( :some_non_atomic_accessor ).should == true
+      persistent_attribute?( :some_non_atomic_reader ).should == true
+      persistent_attribute?( :some_non_atomic_writer ).should == true
+      persistent_attribute?( :some_non_atomic_other_accessor ).should == false
+      persistent_attribute?( :some_non_atomic_other_reader ).should == false
+      persistent_attribute?( :some_non_atomic_other_writer ).should == false
+
+      persistent_attribute?( :some_non_atomic_accessor ).should == true
+      persistent_attribute?( :some_non_atomic_reader ).should == true
+      persistent_attribute?( :some_non_atomic_writer ).should == true
+      persistent_attribute?( :some_non_atomic_other_accessor ).should == false
+      persistent_attribute?( :some_non_atomic_other_reader ).should == false
+      persistent_attribute?( :some_non_atomic_other_writer ).should == false
+
+      persistent_attribute?( :some_atomic_accessor ).should == true
+      persistent_attribute?( :some_atomic_reader ).should == true
+      persistent_attribute?( :some_atomic_writer ).should == true
+      persistent_attribute?( :some_atomic_other_accessor ).should == false
+      persistent_attribute?( :some_atomic_other_reader ).should == false
+      persistent_attribute?( :some_atomic_other_writer ).should == false
+                                   
+      persistent_attribute?( :some_atomic_accessor ).should == true
+      persistent_attribute?( :some_atomic_reader ).should == true
+      persistent_attribute?( :some_atomic_writer ).should == true
+      persistent_attribute?( :some_atomic_other_accessor ).should == false
+      persistent_attribute?( :some_atomic_other_reader ).should == false
+      persistent_attribute?( :some_atomic_other_writer ).should == false
+
+    end
+  end
+
+  ####################################
+  #  persistent_attribute_accessor?  #
+  ####################################
+  
+  it 'can report whether an attribute is a persistent :accessor' do
+    class ::Persistence::Object::Complex::Attributes::PersistentAttributeAccessorQ
+      include ::Persistence::Object::Complex
+      non_atomic_attributes[ :some_non_atomic_accessor ] = :accessor
+      non_atomic_attributes[ :some_non_atomic_reader ] = :reader
+      non_atomic_attributes[ :some_non_atomic_writer ] = :writer
+      atomic_attributes[ :some_atomic_accessor ] = :accessor
+      atomic_attributes[ :some_atomic_reader ] = :reader
+      atomic_attributes[ :some_atomic_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::PersistentAttributeAccessorQ.new.instance_eval do
+
+      persistent_attribute_accessor?( :some_non_atomic_accessor ).should == true
+      persistent_attribute_accessor?( :some_non_atomic_reader ).should == false
+      persistent_attribute_accessor?( :some_non_atomic_writer ).should == false
+      persistent_attribute_accessor?( :some_non_atomic_other_accessor ).should == false
+      persistent_attribute_accessor?( :some_non_atomic_other_reader ).should == false
+      persistent_attribute_accessor?( :some_non_atomic_other_writer ).should == false
+
+      persistent_attribute_accessor?( :some_non_atomic_accessor ).should == true
+      persistent_attribute_accessor?( :some_non_atomic_reader ).should == false
+      persistent_attribute_accessor?( :some_non_atomic_writer ).should == false
+      persistent_attribute_accessor?( :some_non_atomic_other_accessor ).should == false
+      persistent_attribute_accessor?( :some_non_atomic_other_reader ).should == false
+      persistent_attribute_accessor?( :some_non_atomic_other_writer ).should == false
+
+      persistent_attribute_accessor?( :some_atomic_accessor ).should == true
+      persistent_attribute_accessor?( :some_atomic_reader ).should == false
+      persistent_attribute_accessor?( :some_atomic_writer ).should == false
+      persistent_attribute_accessor?( :some_atomic_other_accessor ).should == false
+      persistent_attribute_accessor?( :some_atomic_other_reader ).should == false
+      persistent_attribute_accessor?( :some_atomic_other_writer ).should == false
+
+      persistent_attribute_accessor?( :some_atomic_accessor ).should == true
+      persistent_attribute_accessor?( :some_atomic_reader ).should == false
+      persistent_attribute_accessor?( :some_atomic_writer ).should == false
+      persistent_attribute_accessor?( :some_atomic_other_accessor ).should == false
+      persistent_attribute_accessor?( :some_atomic_other_reader ).should == false
+      persistent_attribute_accessor?( :some_atomic_other_writer ).should == false
+
+    end
+  end
+
+  ##################################
+  #  persistent_attribute_reader?  #
+  ##################################
+  
+  it 'can report whether an attribute is a persistent :reader' do
+    class ::Persistence::Object::Complex::Attributes::PersistentAttributeReaderQ
+      include ::Persistence::Object::Complex
+      non_atomic_attributes[ :some_non_atomic_accessor ] = :accessor
+      non_atomic_attributes[ :some_non_atomic_reader ] = :reader
+      non_atomic_attributes[ :some_non_atomic_writer ] = :writer
+      atomic_attributes[ :some_atomic_accessor ] = :accessor
+      atomic_attributes[ :some_atomic_reader ] = :reader
+      atomic_attributes[ :some_atomic_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::PersistentAttributeReaderQ.new.instance_eval do
+
+      persistent_attribute_reader?( :some_non_atomic_accessor ).should == true
+      persistent_attribute_reader?( :some_non_atomic_reader ).should == true
+      persistent_attribute_reader?( :some_non_atomic_writer ).should == false
+      persistent_attribute_reader?( :some_non_atomic_other_accessor ).should == false
+      persistent_attribute_reader?( :some_non_atomic_other_reader ).should == false
+      persistent_attribute_reader?( :some_non_atomic_other_writer ).should == false
+
+      persistent_attribute_reader?( :some_non_atomic_accessor ).should == true
+      persistent_attribute_reader?( :some_non_atomic_reader ).should == true
+      persistent_attribute_reader?( :some_non_atomic_writer ).should == false
+      persistent_attribute_reader?( :some_non_atomic_other_accessor ).should == false
+      persistent_attribute_reader?( :some_non_atomic_other_reader ).should == false
+      persistent_attribute_reader?( :some_non_atomic_other_writer ).should == false
+
+      persistent_attribute_reader?( :some_atomic_accessor ).should == true
+      persistent_attribute_reader?( :some_atomic_reader ).should == true
+      persistent_attribute_reader?( :some_atomic_writer ).should == false
+      persistent_attribute_reader?( :some_atomic_other_accessor ).should == false
+      persistent_attribute_reader?( :some_atomic_other_reader ).should == false
+      persistent_attribute_reader?( :some_atomic_other_writer ).should == false
+
+      persistent_attribute_reader?( :some_atomic_accessor ).should == true
+      persistent_attribute_reader?( :some_atomic_reader ).should == true
+      persistent_attribute_reader?( :some_atomic_writer ).should == false
+      persistent_attribute_reader?( :some_atomic_other_accessor ).should == false
+      persistent_attribute_reader?( :some_atomic_other_reader ).should == false
+      persistent_attribute_reader?( :some_atomic_other_writer ).should == false
+
+    end
+  end
+
+  ##################################
+  #  persistent_attribute_writer?  #
+  ##################################
+  
+  it 'can report whether an attribute is a persistent :writer' do
+    class ::Persistence::Object::Complex::Attributes::PersistentAttributeWriterQ
+      include ::Persistence::Object::Complex
+      non_atomic_attributes[ :some_non_atomic_accessor ] = :accessor
+      non_atomic_attributes[ :some_non_atomic_reader ] = :reader
+      non_atomic_attributes[ :some_non_atomic_writer ] = :writer
+      atomic_attributes[ :some_atomic_accessor ] = :accessor
+      atomic_attributes[ :some_atomic_reader ] = :reader
+      atomic_attributes[ :some_atomic_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::PersistentAttributeWriterQ.new.instance_eval do
+
+      persistent_attribute_writer?( :some_non_atomic_accessor ).should == true
+      persistent_attribute_writer?( :some_non_atomic_reader ).should == false
+      persistent_attribute_writer?( :some_non_atomic_writer ).should == true
+      persistent_attribute_writer?( :some_non_atomic_other_accessor ).should == false
+      persistent_attribute_writer?( :some_non_atomic_other_reader ).should == false
+      persistent_attribute_writer?( :some_non_atomic_other_writer ).should == false
+
+      persistent_attribute_writer?( :some_non_atomic_accessor ).should == true
+      persistent_attribute_writer?( :some_non_atomic_reader ).should == false
+      persistent_attribute_writer?( :some_non_atomic_writer ).should == true
+      persistent_attribute_writer?( :some_non_atomic_other_accessor ).should == false
+      persistent_attribute_writer?( :some_non_atomic_other_reader ).should == false
+      persistent_attribute_writer?( :some_non_atomic_other_writer ).should == false
+
+      persistent_attribute_writer?( :some_atomic_accessor ).should == true
+      persistent_attribute_writer?( :some_atomic_reader ).should == false
+      persistent_attribute_writer?( :some_atomic_writer ).should == true
+      persistent_attribute_writer?( :some_atomic_other_accessor ).should == false
+      persistent_attribute_writer?( :some_atomic_other_reader ).should == false
+      persistent_attribute_writer?( :some_atomic_other_writer ).should == false
+
+      persistent_attribute_writer?( :some_atomic_accessor ).should == true
+      persistent_attribute_writer?( :some_atomic_reader ).should == false
+      persistent_attribute_writer?( :some_atomic_writer ).should == true
+      persistent_attribute_writer?( :some_atomic_other_accessor ).should == false
+      persistent_attribute_writer?( :some_atomic_other_reader ).should == false
+      persistent_attribute_writer?( :some_atomic_other_writer ).should == false
+
+    end
+  end
+
+  #################################
+  #  persistent_attribute_status  #
+  #################################
+  
+  it 'can report the current persistent status (:accessor, :reader, :writer) of an attribute' do
+    class ::Persistence::Object::Complex::Attributes::PersistentAttributeStatus
+      include ::Persistence::Object::Complex
+      non_atomic_attributes[ :some_non_atomic_accessor ] = :accessor
+      non_atomic_attributes[ :some_non_atomic_reader ] = :reader
+      non_atomic_attributes[ :some_non_atomic_writer ] = :writer
+      atomic_attributes[ :some_atomic_accessor ] = :accessor
+      atomic_attributes[ :some_atomic_reader ] = :reader
+      atomic_attributes[ :some_atomic_writer ] = :writer
+    end
+    ::Persistence::Object::Complex::Attributes::PersistentAttributeStatus.new.instance_eval do
+
+      persistent_attribute_status( :some_non_atomic_accessor ).should == :accessor
+      persistent_attribute_status( :some_non_atomic_reader ).should == :reader
+      persistent_attribute_status( :some_non_atomic_writer ).should == :writer
+      persistent_attribute_status( :some_non_atomic_other_accessor ).should == nil
+      persistent_attribute_status( :some_non_atomic_other_reader ).should == nil
+      persistent_attribute_status( :some_non_atomic_other_writer ).should == nil
+
+      persistent_attribute_status( :some_non_atomic_accessor ).should == :accessor
+      persistent_attribute_status( :some_non_atomic_reader ).should == :reader
+      persistent_attribute_status( :some_non_atomic_writer ).should == :writer
+      persistent_attribute_status( :some_non_atomic_other_accessor ).should == nil
+      persistent_attribute_status( :some_non_atomic_other_reader ).should == nil
+      persistent_attribute_status( :some_non_atomic_other_writer ).should == nil
+
+      persistent_attribute_status( :some_atomic_accessor ).should == :accessor
+      persistent_attribute_status( :some_atomic_reader ).should == :reader
+      persistent_attribute_status( :some_atomic_writer ).should == :writer
+      persistent_attribute_status( :some_atomic_other_accessor ).should == nil
+      persistent_attribute_status( :some_atomic_other_reader ).should == nil
+      persistent_attribute_status( :some_atomic_other_writer ).should == nil
+
+      persistent_attribute_status( :some_atomic_accessor ).should == :accessor
+      persistent_attribute_status( :some_atomic_reader ).should == :reader
+      persistent_attribute_status( :some_atomic_writer ).should == :writer
+      persistent_attribute_status( :some_atomic_other_accessor ).should == nil
+      persistent_attribute_status( :some_atomic_other_reader ).should == nil
+      persistent_attribute_status( :some_atomic_other_writer ).should == nil
+
+    end
+  end
+
+end