state_machine 0.4.3 → 0.5.0

data/test/unit/integrations/sequel_test.rb

@@ -54,6 +54,7 @@ begin
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
+        @machine.state :parked, :idling, :first_gear
       end
       
       def test_should_create_singular_with_scope
@@ -61,10 +62,10 @@ begin
       end
       
       def test_should_only_include_records_with_state_in_singular_with_scope
-        off = @model.create :state => 'off'
-        on = @model.create :state => 'on'
+        parked = @model.create :state => 'parked'
+        idling = @model.create :state => 'idling'
         
-        assert_equal [off], @model.with_state('off').all
+        assert_equal [parked], @model.with_state(:parked).all
       end
       
       def test_should_create_plural_with_scope
@@ -72,10 +73,10 @@ begin
       end
       
       def test_should_only_include_records_with_states_in_plural_with_scope
-        off = @model.create :state => 'off'
-        on = @model.create :state => 'on'
+        parked = @model.create :state => 'parked'
+        idling = @model.create :state => 'idling'
         
-        assert_equal [off, on], @model.with_states('off', 'on').all
+        assert_equal [parked, idling], @model.with_states(:parked, :idling).all
       end
       
       def test_should_create_singular_without_scope
@@ -83,10 +84,10 @@ begin
       end
       
       def test_should_only_include_records_without_state_in_singular_without_scope
-        off = @model.create :state => 'off'
-        on = @model.create :state => 'on'
+        parked = @model.create :state => 'parked'
+        idling = @model.create :state => 'idling'
         
-        assert_equal [off], @model.without_state('on').all
+        assert_equal [parked], @model.without_state(:idling).all
       end
       
       def test_should_create_plural_without_scope
@@ -94,11 +95,18 @@ begin
       end
       
       def test_should_only_include_records_without_states_in_plural_without_scope
-        off = @model.create :state => 'off'
-        on = @model.create :state => 'on'
-        error = @model.create :state => 'error'
+        parked = @model.create :state => 'parked'
+        idling = @model.create :state => 'idling'
+        first_gear = @model.create :state => 'first_gear'
         
-        assert_equal [off, on], @model.without_states('error').all
+        assert_equal [parked, idling], @model.without_states(:first_gear).all
+      end
+      
+      def test_should_allow_chaining_scopes_and_fitlers
+        parked = @model.create :state => 'parked'
+        idling = @model.create :state => 'idling'
+        
+        assert_equal [idling], @model.without_state(:parked).filter(:state => 'idling').all
       end
       
       def test_should_rollback_transaction_if_false
@@ -121,14 +129,14 @@ begin
       
       def test_should_not_override_the_column_reader
         record = @model.new
-        record[:state] = 'off'
-        assert_equal 'off', record.state
+        record[:state] = 'parked'
+        assert_equal 'parked', record.state
       end
       
       def test_should_not_override_the_column_writer
         record = @model.new
-        record.state = 'off'
-        assert_equal 'off', record[:state]
+        record.state = 'parked'
+        assert_equal 'parked', record[:state]
       end
     end
     
@@ -145,19 +153,19 @@ begin
     class MachineWithInitialStateTest < BaseTestCase
       def setup
         @model = new_model
-        @machine = StateMachine::Machine.new(@model, :initial => 'off')
+        @machine = StateMachine::Machine.new(@model, :initial => 'parked')
         @record = @model.new
       end
       
       def test_should_set_initial_state_on_created_object
-        assert_equal 'off', @record.state
+        assert_equal 'parked', @record.state
       end
     end
     
     class MachineWithNonColumnStateAttributeTest < BaseTestCase
       def setup
         @model = new_model
-        @machine = StateMachine::Machine.new(@model, :status, :initial => 'off')
+        @machine = StateMachine::Machine.new(@model, :status, :initial => 'parked')
         @record = @model.new
       end
       
@@ -170,7 +178,7 @@ begin
       end
       
       def test_should_set_initial_state_on_created_object
-        assert_equal 'off', @record.status
+        assert_equal 'parked', @record.status
       end
     end
     
@@ -178,8 +186,9 @@ begin
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
-        @record = @model.new(:state => 'off')
-        @transition = StateMachine::Transition.new(@record, @machine, 'turn_on', 'off', 'on')
+        @machine.state :parked, :idling
+        @record = @model.new(:state => 'parked')
+        @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
       end
       
       def test_should_run_before_callbacks
@@ -242,11 +251,11 @@ begin
         callback_args = nil
         
         klass = class << @record; self; end
-        klass.send(:define_method, :after_turn_on) do |*args|
+        klass.send(:define_method, :after_ignite) do |*args|
           callback_args = args
         end
         
-        @machine.before_transition(:after_turn_on)
+        @machine.before_transition(:after_ignite)
         
         @transition.perform
         assert_equal [@transition], callback_args

data/test/unit/integrations_test.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class IntegrationMatcherTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+  end
+  
+  def test_should_return_nil_if_no_match_found
+    assert_nil StateMachine::Integrations.match(@klass)
+  end
+  
+  def test_should_return_integration_class_if_match_found
+    integration = Module.new do
+      def self.matches?(klass)
+        true
+      end
+    end
+    StateMachine::Integrations.const_set('Custom', integration)
+    
+    assert_equal integration, StateMachine::Integrations.match(@klass)
+  ensure
+    StateMachine::Integrations.send(:remove_const, 'Custom')
+  end
+end
+
+class IntegrationFinderTest < Test::Unit::TestCase
+  def test_should_find_active_record
+    assert_equal StateMachine::Integrations::ActiveRecord, StateMachine::Integrations.find(:active_record)
+  end
+  
+  def test_should_find_data_mapper
+    assert_equal StateMachine::Integrations::DataMapper, StateMachine::Integrations.find(:data_mapper)
+  end
+  
+  def test_should_find_sequel
+    assert_equal StateMachine::Integrations::Sequel, StateMachine::Integrations.find(:sequel)
+  end
+  
+  def test_should_raise_an_exception_if_invalid
+    assert_raise(NameError) { StateMachine::Integrations.find(:invalid) }
+  end
+end

data/test/unit/machine_test.rb

@@ -12,15 +12,19 @@ class MachineByDefaultTest < Test::Unit::TestCase
   end
   
   def test_should_have_an_attribute
-    assert_equal 'state', @machine.attribute
+    assert_equal :state, @machine.attribute
   end
   
-  def test_should_not_have_an_initial_state
-    assert_nil @machine.initial_state(@object)
+  def test_should_have_an_initial_state
+    assert_not_nil @machine.initial_state(@object)
+  end
+  
+  def test_should_have_a_nil_initial_state
+    assert_nil @machine.initial_state(@object).value
   end
   
   def test_should_not_have_any_events
-    assert @machine.events.empty?
+    assert !@machine.events.any?
   end
   
   def test_should_not_have_any_before_callbacks
@@ -35,6 +39,10 @@ class MachineByDefaultTest < Test::Unit::TestCase
     assert_nil @machine.action
   end
   
+  def test_should_not_have_a_namespace
+    assert_nil @machine.namespace
+  end
+  
   def test_should_have_a_nil_state
     assert_equal [nil], @machine.states.keys
   end
@@ -67,6 +75,10 @@ class MachineByDefaultTest < Test::Unit::TestCase
     assert @object.respond_to?(:state?)
   end
   
+  def test_should_define_a_name_reader_for_the_attribute
+    assert @object.respond_to?(:state_name)
+  end
+  
   def test_should_not_define_singular_with_scope
     assert !@klass.respond_to?(:with_state)
   end
@@ -92,7 +104,7 @@ class MachineByDefaultTest < Test::Unit::TestCase
   end
   
   def test_should_define_state_machines_reader
-    expected = {'state' => @machine}
+    expected = {:state => @machine}
     assert_equal expected, @klass.state_machines
   end
 end
@@ -100,12 +112,12 @@ end
 class MachineWithCustomAttributeTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, 'status')
+    @machine = StateMachine::Machine.new(@klass, :status)
     @object = @klass.new
   end
   
   def test_should_use_custom_attribute
-    assert_equal 'status', @machine.attribute
+    assert_equal :status, @machine.attribute
   end
   
   def test_should_define_a_reader_attribute_for_the_attribute
@@ -119,6 +131,10 @@ class MachineWithCustomAttributeTest < Test::Unit::TestCase
   def test_should_define_a_predicate_for_the_attribute
     assert @object.respond_to?(:status?)
   end
+  
+  def test_should_define_a_name_reader_for_the_attribute
+    assert @object.respond_to?(:status_name)
+  end
 end
 
 class MachineWithStaticInitialStateTest < Test::Unit::TestCase
@@ -130,61 +146,35 @@ class MachineWithStaticInitialStateTest < Test::Unit::TestCase
       end
     end
     
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
   end
   
   def test_should_have_an_initial_state
     object = @klass.new
-    assert_equal 'off', @machine.initial_state(object)
+    assert_equal 'parked', @machine.initial_state(object).value
   end
   
   def test_should_set_initial_on_state_object
-    assert @machine.state('off').initial
+    assert @machine.state(:parked).initial
   end
   
   def test_should_set_initial_state_if_existing_is_nil
     object = @klass.new(:state => nil)
-    assert_equal 'off', object.state
+    assert_equal 'parked', object.state
   end
   
   def test_should_set_initial_state_if_existing_is_empty
     object = @klass.new(:state => '')
-    assert_equal 'off', object.state
+    assert_equal 'parked', object.state
   end
   
   def test_should_not_set_initial_state_if_existing_is_not_empty
-    object = @klass.new(:state => 'on')
-    assert_equal 'on', object.state
+    object = @klass.new(:state => 'idling')
+    assert_equal 'idling', object.state
   end
   
   def test_should_be_included_in_known_states
-    assert_equal %w(off), @machine.states.keys
-  end
-  
-  def test_should_order_state_before_transition_states
-    @machine.event :turn_on do
-      transition :from => 'off', :to => 'on'
-    end
-    assert_equal %w(off on), @machine.states_order
-  end
-  
-  def test_should_order_state_before_states_with_behaviors
-    @machine.state 'error' do
-      def color
-        'red'
-      end
-    end
-    assert_equal %w(off error), @machine.states_order
-  end
-  
-  def test_should_order_state_before_other_states
-    @machine.other_states 'on'
-    assert_equal %w(off on), @machine.states_order
-  end
-  
-  def test_should_order_state_before_callback_states
-    @machine.before_transition :from => 'on', :do => lambda {}
-    assert_equal %w(off on), @machine.states_order
+    assert_equal [:parked], @machine.states.keys
   end
 end
 
@@ -193,25 +183,25 @@ class MachineWithDynamicInitialStateTest < Test::Unit::TestCase
     @klass = Class.new do
       attr_accessor :initial_state
     end
-    @initial_state = lambda {|object| object.initial_state || 'default'}
-    @machine = StateMachine::Machine.new(@klass, :initial => @initial_state)
+    @machine = StateMachine::Machine.new(@klass, :initial => lambda {|object| object.initial_state || :default})
+    @machine.state :parked, :idling, :default
     @object = @klass.new
   end
   
   def test_should_use_the_record_for_determining_the_initial_state
-    @object.initial_state = 'off'
-    assert_equal 'off', @machine.initial_state(@object)
+    @object.initial_state = :parked
+    assert_equal :parked, @machine.initial_state(@object).name
     
-    @object.initial_state = 'on'
-    assert_equal 'on', @machine.initial_state(@object)
+    @object.initial_state = :idling
+    assert_equal :idling, @machine.initial_state(@object).name
   end
   
   def test_should_set_initial_state_on_created_object
     assert_equal 'default', @object.state
   end
   
-  def test_should_be_included_in_known_states
-    assert_equal [@initial_state], @machine.states.keys
+  def test_should_not_be_included_in_known_states
+    assert_equal [:parked, :idling, :default], @machine.states.map {|state| state.name}
   end
 end
 
@@ -245,36 +235,6 @@ class MachineWithNilActionTest < Test::Unit::TestCase
   end
 end
 
-class MachineWithCustomIntegrationTest < Test::Unit::TestCase
-  def setup
-    StateMachine::Integrations.const_set('Custom', Module.new)
-    @machine = StateMachine::Machine.new(Class.new, :integration => :custom)
-  end
-  
-  def test_should_be_extended_by_the_integration
-    assert (class << @machine; ancestors; end).include?(StateMachine::Integrations::Custom)
-  end
-  
-  def teardown
-    StateMachine::Integrations.send(:remove_const, 'Custom')
-  end
-end
-
-class MachineTest < Test::Unit::TestCase
-  def test_should_raise_exception_if_invalid_option_specified
-    assert_raise(ArgumentError) {StateMachine::Machine.new(Class.new, :invalid => true)}
-  end
-  
-  def test_should_evaluate_a_block_during_initialization
-    called = true
-    StateMachine::Machine.new(Class.new) do
-      called = respond_to?(:event)
-    end
-    
-    assert called
-  end
-end
-
 class MachineWithoutIntegrationTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
@@ -292,6 +252,21 @@ class MachineWithoutIntegrationTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithCustomIntegrationTest < Test::Unit::TestCase
+  def setup
+    StateMachine::Integrations.const_set('Custom', Module.new)
+    @machine = StateMachine::Machine.new(Class.new, :integration => :custom)
+  end
+  
+  def test_should_be_extended_by_the_integration
+    assert (class << @machine; ancestors; end).include?(StateMachine::Integrations::Custom)
+  end
+  
+  def teardown
+    StateMachine::Integrations.send(:remove_const, 'Custom')
+  end
+end
+
 class MachineWithIntegrationTest < Test::Unit::TestCase
   def setup
     @integration = Module.new do
@@ -308,12 +283,14 @@ class MachineWithIntegrationTest < Test::Unit::TestCase
         :save
       end
       
-      def define_with_scope(name)
+      def create_with_scope(name)
         StateMachine::Integrations::Custom.with_scopes << name
+        lambda {}
       end
       
-      def define_without_scope(name)
+      def create_without_scope(name)
         StateMachine::Integrations::Custom.without_scopes << name
+        lambda {}
       end
     end
     
@@ -347,15 +324,65 @@ class MachineWithIntegrationTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithCustomPluralTest < Test::Unit::TestCase
+  def setup
+    @integration = Module.new do
+      class << self; attr_accessor :with_scopes, :without_scopes; end
+      @initialized = false
+      @with_scopes = []
+      @without_scopes = []
+      
+      def create_with_scope(name)
+        StateMachine::Integrations::Custom.with_scopes << name
+        lambda {}
+      end
+      
+      def create_without_scope(name)
+        StateMachine::Integrations::Custom.without_scopes << name
+        lambda {}
+      end
+    end
+    
+    StateMachine::Integrations.const_set('Custom', @integration)
+    @machine = StateMachine::Machine.new(Class.new, :integration => :custom, :plural => 'staties')
+  end
+  
+  def test_should_define_a_singular_and_plural_with_scope
+    assert_equal %w(with_state with_staties), @integration.with_scopes
+  end
+  
+  def test_should_define_a_singular_and_plural_without_scope
+    assert_equal %w(without_state without_staties), @integration.without_scopes
+  end
+  
+  def teardown
+    StateMachine::Integrations.send(:remove_const, 'Custom')
+  end
+end
+
+class MachineTest < Test::Unit::TestCase
+  def test_should_raise_exception_if_invalid_option_specified
+    assert_raise(ArgumentError) {StateMachine::Machine.new(Class.new, :invalid => true)}
+  end
+  
+  def test_should_evaluate_a_block_during_initialization
+    called = true
+    StateMachine::Machine.new(Class.new) do
+      called = respond_to?(:event)
+    end
+    
+    assert called
+  end
+end
+
 class MachineAfterBeingCopiedTest < Test::Unit::TestCase
   def setup
-    @machine = StateMachine::Machine.new(Class.new, 'state', :initial => 'off')
-    @machine.event(:turn_on) {}
+    @machine = StateMachine::Machine.new(Class.new, :state, :initial => :parked)
+    @machine.event(:ignite) {}
     @machine.before_transition(lambda {})
     @machine.after_transition(lambda {})
-    @machine.states # Caches the states variable
     
-    @copied_machine = @machine.dup
+    @copied_machine = @machine.clone
   end
   
   def test_should_not_have_the_same_collection_of_states
@@ -363,15 +390,15 @@ class MachineAfterBeingCopiedTest < Test::Unit::TestCase
   end
   
   def test_should_copy_each_state
-    assert_not_same @copied_machine.states['off'], @machine.states['off']
+    assert_not_same @copied_machine.states[:parked], @machine.states[:parked]
   end
   
   def test_should_update_machine_for_each_state
-    assert_equal @copied_machine, @copied_machine.states['off'].machine
+    assert_equal @copied_machine, @copied_machine.states[:parked].machine
   end
   
   def test_should_not_update_machine_for_original_state
-    assert_equal @machine, @machine.states['off'].machine
+    assert_equal @machine, @machine.states[:parked].machine
   end
   
   def test_should_not_have_the_same_collection_of_events
@@ -379,19 +406,15 @@ class MachineAfterBeingCopiedTest < Test::Unit::TestCase
   end
   
   def test_should_copy_each_event
-    assert_not_same @copied_machine.events['turn_on'], @machine.events['turn_on']
+    assert_not_same @copied_machine.events[:ignite], @machine.events[:ignite]
   end
   
   def test_should_update_machine_for_each_event
-    assert_equal @copied_machine, @copied_machine.events['turn_on'].machine
+    assert_equal @copied_machine, @copied_machine.events[:ignite].machine
   end
   
   def test_should_not_update_machine_for_original_event
-    assert_equal @machine, @machine.events['turn_on'].machine
-  end
-  
-  def test_should_not_have_the_same_events_order
-    assert_not_same @copied_machine.events_order, @machine.events_order
+    assert_equal @machine, @machine.events[:ignite].machine
   end
   
   def test_should_not_have_the_same_callbacks
@@ -407,21 +430,18 @@ class MachineAfterBeingCopiedTest < Test::Unit::TestCase
   end
 end
 
-class MachineAfterChangingContextTest < Test::Unit::TestCase
+class MachineAfterChangingOwnerClassTest < Test::Unit::TestCase
   def setup
     @original_class = Class.new
-    @machine = StateMachine::Machine.new(@original_class, 'state')
+    @machine = StateMachine::Machine.new(@original_class)
     
     @new_class = Class.new(@original_class)
-    @new_machine = @machine.within_context(@new_class)
+    @new_machine = @machine.clone
+    @new_machine.owner_class = @new_class
     
     @object = @new_class.new
   end
   
-  def test_should_create_copy_of_machine
-    assert_not_same @machine, @new_machine
-  end
-  
   def test_should_update_owner_class
     assert_equal @new_class, @new_machine.owner_class
   end
@@ -430,53 +450,38 @@ class MachineAfterChangingContextTest < Test::Unit::TestCase
     assert_equal @original_class, @machine.owner_class
   end
   
-  def test_should_still_have_an_initial_state
-    assert @new_machine.states[nil].initial
-  end
-  
-  def test_should_allow_changing_the_initial_state
-    new_machine = @machine.within_context(@new_class, :initial => 'off')
-    
-    assert_equal 'off', new_machine.initial_state(@object)
-    assert new_machine.state('off').initial
-    assert !new_machine.state(nil).initial
-  end
-  
-  def test_should_not_change_original_initial_state_if_updated
-    new_machine = @machine.within_context(@new_class, :initial => 'off')
-    assert_nil @machine.initial_state(@object)
-  end
-  
-  def test_should_not_update_initial_state_if_not_provided
-    assert_nil @new_machine.initial_state(@object)
+  def test_should_change_the_associated_machine_in_the_new_class
+    assert_equal @new_machine, @new_class.state_machines[:state]
   end
   
-  def test_should_allow_changing_the_integration
-    StateMachine::Integrations.const_set('Custom', Module.new)
-    new_machine = @machine.within_context(@new_class, :integration => :custom)
-    assert (class << new_machine; ancestors; end).include?(StateMachine::Integrations::Custom)
+  def test_should_not_change_the_associated_machine_in_the_original_class
+    assert_equal @machine, @original_class.state_machines[:state]
   end
-  
-  def test_should_not_change_original_integration_if_updated
-    StateMachine::Integrations.const_set('Custom', Module.new)
-    new_machine = @machine.within_context(@new_class, :integration => :custom)
-    assert !(class << @machine; ancestors; end).include?(StateMachine::Integrations::Custom)
+end
+
+class MachineAfterChangingInitialState < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @machine.initial_state = :idling
+    
+    @object = @klass.new
   end
   
-  def test_should_change_the_associated_machine_in_the_new_class
-    assert_equal @new_machine, @new_class.state_machines['state']
+  def test_should_change_the_initial_state
+    assert_equal :idling, @machine.initial_state(@object).name
   end
   
-  def test_should_not_change_the_associated_machine_in_the_original_class
-    assert_equal @machine, @original_class.state_machines['state']
+  def test_should_include_in_known_states
+    assert_equal [:parked, :idling], @machine.states.map {|state| state.name}
   end
   
-  def test_raise_exception_if_invalid_option_specified
-    assert_raise(ArgumentError) {@machine.within_context(@new_class, :invalid => true)}
+  def test_should_reset_original_initial_state
+    assert !@machine.state(:parked).initial
   end
   
-  def teardown
-    StateMachine::Integrations.send(:remove_const, 'Custom') if StateMachine::Integrations.const_defined?('Custom')
+  def test_should_set_new_state_to_initial
+    assert @machine.state(:idling).initial
   end
 end
 
@@ -496,24 +501,32 @@ class MachineWithConflictingAttributeAccessorsTest < Test::Unit::TestCase
       def state?
         true
       end
+      
+      def state_name
+        :parked
+      end
     end
     @machine = StateMachine::Machine.new(@klass)
     @object = @klass.new
   end
   
   def test_should_not_define_attribute_reader
-    @object.status = 'on'
-    assert_equal 'on', @object.state
+    @object.status = 'parked'
+    assert_equal 'parked', @object.state
   end
   
   def test_should_not_define_attribute_writer
-    @object.state = 'on'
-    assert_equal 'on', @object.status
+    @object.state = 'parked'
+    assert_equal 'parked', @object.status
   end
   
   def test_should_not_define_attribute_predicate
     assert @object.state?
   end
+  
+  def test_should_define_attribute_name_reader
+    assert_nil @object.state_name
+  end
 end
 
 class MachineWithConflictingPrivateAttributeAccessorsTest < Test::Unit::TestCase
@@ -533,24 +546,32 @@ class MachineWithConflictingPrivateAttributeAccessorsTest < Test::Unit::TestCase
         def state?
           true
         end
+        
+        def state_name
+          :parked
+        end
     end
     @machine = StateMachine::Machine.new(@klass)
     @object = @klass.new
   end
   
   def test_should_not_define_attribute_reader
-    @object.status = 'on'
-    assert_equal 'on', @object.send(:state)
+    @object.status = 'parked'
+    assert_equal 'parked', @object.send(:state)
   end
   
   def test_should_not_define_attribute_writer
-    @object.send(:state=, 'on')
-    assert_equal 'on', @object.status
+    @object.send(:state=, 'parked')
+    assert_equal 'parked', @object.status
   end
   
   def test_should_not_define_attribute_predicate
     assert @object.send(:state?)
   end
+  
+  def test_should_define_attribute_name_reader
+    assert_nil @object.send(:state_name)
+  end
 end
 
 class MachineWithConflictingScopesTest < Test::Unit::TestCase
@@ -607,312 +628,316 @@ class MachineWithConflictingScopesTest < Test::Unit::TestCase
   end
 end
 
-class MachineWithEventsTest < Test::Unit::TestCase
+class MachineWithoutInitializeTest < Test::Unit::TestCase
   def setup
-    @machine = StateMachine::Machine.new(Class.new)
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @object = @klass.new
   end
   
-  def test_should_create_event_with_given_name
-    event = @machine.event(:turn_on) {}
-    assert_equal 'turn_on', event.name
+  def test_should_initialize_state
+    assert_equal 'parked', @object.state
   end
-  
-  def test_should_evaluate_block_within_event_context
-    responded = false
-    @machine.event :turn_on do
-      responded = respond_to?(:transition)
+end
+
+class MachineWithInitializeWithoutSuperTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new do
+      def initialize
+      end
     end
-    
-    assert responded
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @object = @klass.new
   end
   
-  def test_should_have_events
-    @machine.event(:turn_on)
-    assert_equal %w(turn_on), @machine.events.keys
+  def test_should_not_initialize_state
+    assert_nil @object.state
+  end
+end
+
+class MachineWithInitializeAndSuperTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new do
+      def initialize
+        super()
+      end
+    end
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @object = @klass.new
   end
   
-  def test_should_return_the_created_event
-    assert_instance_of StateMachine::Event, @machine.event(:turn_on)
+  def test_should_initialize_state
+    assert_equal 'parked', @object.state
   end
 end
 
-class MachineWithConflictingPredefinedInitializeTest < Test::Unit::TestCase
+class MachineWithInitializeArgumentsAndBlockTest < Test::Unit::TestCase
   def setup
-    @klass = Class.new do
-      attr_reader :initialized
+    @superclass = Class.new do
+      attr_reader :args
       attr_reader :block_given
       
-      def initialize
-        @initialized = true
+      def initialize(*args)
+        @args = args
         @block_given = block_given?
-        super()
       end
     end
-    
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
-    @object = @klass.new {}
+    @klass = Class.new(@superclass)
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @object = @klass.new(1, 2, 3) {}
   end
   
-  def test_should_not_override_existing_method
-    assert @object.initialized
+  def test_should_initialize_state
+    assert_equal 'parked', @object.state
   end
   
-  def test_should_still_initialize_state
-    assert_equal 'off', @object.state
+  def test_should_preserve_arguments
+    assert_equal [1, 2, 3], @object.args
   end
   
   def test_should_preserve_block
     assert @object.block_given
   end
-  
-  def test_should_not_include_initialize_in_instance_methods
-    assert !@klass.instance_methods(false).include?('initialize')
-  end
 end
 
-class MachineWithConflictingPostdefinedInitializeTest < Test::Unit::TestCase
+class MachineWithCustomInitializeTest < Test::Unit::TestCase
   def setup
-    @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
-    @klass.class_eval do
-      attr_reader :initialized
-      attr_reader :block_given
-      
+    @klass = Class.new do
       def initialize
-        @initialized = true
-        @block_given = block_given?
-        super()
+        initialize_state_machines
       end
     end
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @object = @klass.new
+  end
+  
+  def test_should_initialize_state
+    assert_equal 'parked', @object.state
+  end
+end
+
+class MachineWithStatesTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @parked, @idling = @machine.state :parked, :idling
     
-    @object = @klass.new {}
+    @object = @klass.new
   end
   
-  def test_should_not_override_existing_method
-    assert @object.initialized
+  def test_should_have_states
+    assert_equal [nil, :parked, :idling], @machine.states.map {|state| state.name}
   end
   
-  def test_should_still_initialize_state
-    assert_equal 'off', @object.state
+  def test_should_allow_state_lookup_by_name
+    assert_equal @parked, @machine.states[:parked]
   end
   
-  def test_should_preserve_block
-    assert @object.block_given
+  def test_should_allow_state_lookup_by_value
+    assert_equal @parked, @machine.states['parked', :value]
   end
   
-  def test_should_not_include_initialize_in_instance_methods
-    assert !@klass.instance_methods(false).include?('initialize')
+  def test_should_use_stringified_name_for_value
+    assert_equal 'parked', @parked.value
   end
-end
-
-class MachineWithConflictingSuperclassInitializeTest < Test::Unit::TestCase
-  def setup
-    @superclass = Class.new do
-      attr_reader :initialized
-      attr_reader :block_given
-      
-      def initialize
-        @initialized = true
-        @block_given = block_given?
-      end
-    end
-    @klass = Class.new(@superclass)
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
-    @object = @klass.new {}
+  
+  def test_should_not_use_custom_matcher
+    assert_nil @parked.matcher
   end
   
-  def test_should_not_override_existing_method
-    assert @object.initialized
+  def test_should_raise_exception_if_invalid_option_specified
+    exception = assert_raise(ArgumentError) {@machine.state(:first_gear, :invalid => true)}
+    assert_equal 'Invalid key(s): invalid', exception.message
   end
   
-  def test_should_still_initialize_state
-    assert_equal 'off', @object.state
+  def test_should_not_be_in_state_if_value_does_not_match
+    assert !@machine.state?(@object, :parked)
+    assert !@machine.state?(@object, :idling)
   end
   
-  def test_should_preserve_block
-    assert @object.block_given
+  def test_should_be_in_state_if_value_matches
+    assert @machine.state?(@object, nil)
   end
   
-  def test_should_not_include_initialize_in_instance_methods
-    assert !@klass.instance_methods(false).include?('initialize')
+  def test_raise_exception_if_checking_invalid_state
+    assert_raise(ArgumentError) { @machine.state?(@object, :invalid) }
+  end
+  
+  def test_should_find_state_for_object_if_value_is_known
+    @object.state = 'parked'
+    assert_equal @parked, @machine.state_for(@object)
+  end
+  
+  def test_should_raise_exception_if_finding_state_for_object_with_unknown_value
+    @object.state = 'invalid'
+    exception = assert_raise(ArgumentError) { @machine.state_for(@object) }
+    assert_equal '"invalid" is not a known state value', exception.message
   end
 end
 
-class MachineWithConflictingPredefinedAndSuperclassInitializeTest < Test::Unit::TestCase
+class MachineWithStatesWithCustomValuesTest < Test::Unit::TestCase
   def setup
-    @superclass = Class.new do
-      attr_reader :base_initialized
-      
-      def initialize
-        @base_initialized = true
-      end
-    end
-    @klass = Class.new(@superclass) do
-      attr_reader :initialized
-      
-      def initialize
-        super
-        @initialized = true
-      end
-    end
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @state = @machine.state :parked, :value => 1
     
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
     @object = @klass.new
+    @object.state = 1
+  end
+  
+  def test_should_use_custom_value
+    assert_equal 1, @state.value
   end
   
-  def test_should_not_override_base_method
-    assert @object.base_initialized
+  def test_should_allow_lookup_by_custom_value
+    assert_equal @state, @machine.states[1, :value]
   end
   
-  def test_should_not_override_existing_method
-    assert @object.initialized
+  def test_should_be_in_state_if_value_matches
+    assert @machine.state?(@object, :parked)
   end
   
-  def test_should_still_initialize_state
-    assert_equal 'off', @object.state
+  def test_should_not_be_in_state_if_value_does_not_match
+    @object.state = 2
+    assert !@machine.state?(@object, :parked)
   end
   
-  def test_should_not_include_initialize_in_instance_methods
-    assert !@klass.instance_methods(false).include?('initialize')
+  def test_should_find_state_for_object_if_value_is_known
+    assert_equal @state, @machine.state_for(@object)
   end
 end
 
-class MachineWithConflictingPostdefinedAndSuperclassInitializeTest < Test::Unit::TestCase
+class MachineWithStateWithMatchersTest < Test::Unit::TestCase
   def setup
-    @superclass = Class.new do
-      attr_reader :base_initialized
-      
-      def initialize
-        @base_initialized = true
-      end
-    end
-    @klass = Class.new(@superclass)    
-    
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
-    @klass.class_eval do
-      attr_reader :initialized
-      
-      def initialize
-        super
-        @initialized = true
-      end
-    end
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @state = @machine.state :parked, :if => lambda {|value| !value.nil?}
     
     @object = @klass.new
+    @object.state = 1
   end
   
-  def test_should_not_override_base_method
-    assert @object.base_initialized
+  def test_should_use_custom_matcher
+    assert_not_nil @state.matcher
+    assert @state.matches?(1)
+    assert !@state.matches?(nil)
   end
   
-  def test_should_not_override_existing_method
-    assert @object.initialized
+  def test_should_be_in_state_if_value_matches
+    assert @machine.state?(@object, :parked)
   end
   
-  def test_should_still_initialize_state
-    assert_equal 'off', @object.state
+  def test_should_not_be_in_state_if_value_does_not_match
+    @object.state = nil
+    assert !@machine.state?(@object, :parked)
   end
   
-  def test_should_not_include_initialize_in_instance_methods
-    assert !@klass.instance_methods(false).include?('initialize')
+  def test_should_find_state_for_object_if_value_is_known
+    assert_equal @state, @machine.state_for(@object)
   end
 end
 
-class MachineWithCustomStateMachineInitializationTest < Test::Unit::TestCase
+class MachineWithStatesWithBehaviorsTest < Test::Unit::TestCase
   def setup
-    @superclass = Class.new do
-      def initialize
-        initialize_state_machines
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    
+    @parked, @idling = @machine.state :parked, :idling do
+      def speed
+        0
       end
     end
-    @klass = Class.new(@superclass)
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
-    @object = @klass.new {}
   end
   
-  def test_should_still_initialize_state
-    assert_equal 'off', @object.state
+  def test_should_define_behaviors_for_each_state
+    assert_not_nil @parked.methods[:speed]
+    assert_not_nil @idling.methods[:speed]
+  end
+  
+  def test_should_define_different_behaviors_for_each_state
+    assert_not_equal @parked.methods[:speed], @idling.methods[:speed]
   end
 end
 
-class MachineWithConflictingMethodAddedTest < Test::Unit::TestCase
+class MachineWithExistingStateTest < Test::Unit::TestCase
   def setup
-    @klass = Class.new do
-      class << self
-        attr_reader :called_method_added
-        
-        def method_added(method)
-          super
-          @called_method_added = true
-        end
-      end
-    end
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
-    @object = @klass.new
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @state = @machine.state :parked
+    @same_state = @machine.state :parked, :value => 1
   end
   
-  def test_should_not_override_existing_method
-    assert @klass.called_method_added
+  def test_should_not_create_a_new_state
+    assert_same @state, @same_state
   end
   
-  def test_should_still_initialize_state
-    assert_equal 'off', @object.state
+  def test_should_update_attributes
+    assert_equal 1, @state.value
+  end
+  
+  def test_should_no_longer_be_able_to_look_up_state_by_original_value
+    assert_nil @machine.states['parked', :value]
+  end
+  
+  def test_should_be_able_to_look_up_state_by_new_value
+    assert_equal @state, @machine.states[1, :value]
   end
 end
 
-class MachineWithExistingAttributeValue < Test::Unit::TestCase
+class MachineWithOtherStates < Test::Unit::TestCase
   def setup
-    @klass = Class.new do
-      def initialize
-        @state = 'on'
-      end
-    end
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
-    @object = @klass.new
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @parked, @idling = @machine.other_states(:parked, :idling)
   end
   
-  def test_should_not_set_the_initial_state
-    assert_equal 'on', @object.state
+  def test_should_include_other_states_in_known_states
+    assert_equal [@parked, @idling], @machine.states.to_a
+  end
+  
+  def test_should_use_default_value
+    assert_equal 'idling', @idling.value
+  end
+  
+  def test_should_not_create_matcher
+    assert_nil @idling.matcher
   end
 end
 
-class MachineWithStateDrivenBehaviorsTest < Test::Unit::TestCase
+class MachineWithEventsTest < Test::Unit::TestCase
   def setup
-    @machine = StateMachine::Machine.new(Class.new, :initial => 'off')
-    @machine.state 'on' do
-      def color
-        'green'
-      end
-    end
+    @machine = StateMachine::Machine.new(Class.new)
   end
   
-  def test_should_order_states_after_initial_state
-    assert_equal %w(off on), @machine.states_order
+  def test_should_return_the_created_event
+    assert_instance_of StateMachine::Event, @machine.event(:ignite)
   end
   
-  def test_should_order_states_after_transition_states
-    @machine.event :turn_on do
-      transition :to => 'error'
-    end
-    assert_equal %w(off error on), @machine.states_order
+  def test_should_create_event_with_given_name
+    event = @machine.event(:ignite) {}
+    assert_equal :ignite, event.name
   end
   
-  def test_should_order_states_before_other_states
-    @machine.other_states 'error'
-    assert_equal %w(off on error), @machine.states_order
+  def test_should_evaluate_block_within_event_context
+    responded = false
+    @machine.event :ignite do
+      responded = respond_to?(:transition)
+    end
+    
+    assert responded
   end
   
-  def test_should_order_state_before_callback_states
-    @machine.before_transition :to => 'error', :do => lambda {}
-    assert_equal %w(off on error), @machine.states_order
+  def test_should_have_events
+    event = @machine.event(:ignite)
+    assert_equal [event], @machine.events.to_a
   end
 end
 
 class MachineWithExistingEventTest < Test::Unit::TestCase
   def setup
     @machine = StateMachine::Machine.new(Class.new)
-    @event = @machine.event(:turn_on)
-    @same_event = @machine.event(:turn_on)
+    @event = @machine.event(:ignite)
+    @same_event = @machine.event(:ignite)
   end
   
   def test_should_not_create_new_event
@@ -920,103 +945,72 @@ class MachineWithExistingEventTest < Test::Unit::TestCase
   end
   
   def test_should_allow_accessing_event_without_block
-    assert_equal @event, @machine.event(:turn_on)
+    assert_equal @event, @machine.event(:ignite)
   end
 end
 
 class MachineWithEventsWithTransitionsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
-    @machine.event(:turn_on) do
-      transition :to => 'on', :from => 'off'
-      transition :to => 'error', :from => 'unknown'
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @event = @machine.event(:ignite) do
+      transition :to => :idling, :from => :parked
+      transition :to => :idling, :from => :stalled
     end
   end
   
   def test_should_have_events
-    assert_equal %w(turn_on), @machine.events.keys
+    assert_equal [@event], @machine.events.to_a
   end
   
   def test_should_track_states_defined_in_event_transitions
-    assert_equal %w(error off on unknown), @machine.states.keys.sort
+    assert_equal [:parked, :idling, :stalled], @machine.states.map {|state| state.name}
   end
   
   def test_should_not_duplicate_states_defined_in_multiple_event_transitions
-    @machine.event :turn_off do
-      transition :to => 'off', :from => 'on'
+    @machine.event :park do
+      transition :to => :parked, :from => :idling
     end
     
-    assert_equal %w(error off on unknown), @machine.states.keys.sort
+    assert_equal [:parked, :idling, :stalled], @machine.states.map {|state| state.name}
   end
   
   def test_should_track_state_from_new_events
-    @machine.states
-    @machine.event :turn_off do
-      transition :to => 'maybe'
+    @machine.event :shift_up do
+      transition :to => :first_gear, :from => :idling
     end
     
-    assert_equal %w(error maybe off on unknown), @machine.states.keys.sort
-  end
-  
-  def test_should_order_states_after_initial_state
-    assert_equal %w(off on error unknown), @machine.states_order
-  end
-  
-  def test_should_order_states_before_states_with_behaviors
-    @machine.state 'tripped' do
-      def color
-        'red'
-      end
-    end
-    assert_equal %w(off on error unknown tripped), @machine.states_order
-  end
-  
-  def test_should_order_states_before_other_states
-    @machine.other_states 'tripped'
-    assert_equal %w(off on error unknown tripped), @machine.states_order
-  end
-  
-  def test_should_order_state_before_callback_states
-    @machine.before_transition :to => 'tripped', :do => lambda {}
-    assert_equal %w(off on error unknown tripped), @machine.states_order
+    assert_equal [:parked, :idling, :stalled, :first_gear], @machine.states.map {|state| state.name}
   end
 end
 
 class MachineWithMultipleEventsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
-    @result = @machine.event(:turn_on, :activate) do
-      transition :to => 'on', :from => 'off'
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @park, @shift_down = @machine.event(:park, :shift_down) do
+      transition :to => :parked, :from => :first_gear
     end
   end
   
   def test_should_have_events
-    assert_equal %w(activate turn_on), @machine.events.keys.sort
+    assert_equal [@park, @shift_down], @machine.events.to_a
   end
   
   def test_should_define_transitions_for_each_event
-    [:turn_on, :activate].each {|event| assert_equal 1, @machine.event(event).guards.size}
+    [@park, @shift_down].each {|event| assert_equal 1, event.guards.size}
   end
   
   def test_should_transition_the_same_for_each_event
     object = @klass.new
-    object.turn_on
-    assert_equal 'on', object.state
+    object.state = 'first_gear'
+    object.park
+    assert_equal 'parked', object.state
     
     object = @klass.new
-    object.activate
-    assert_equal 'on', object.state
-  end
-  
-  def test_should_return_all_created_events
-    assert_instance_of Array, @result
-    assert_equal 2, @result.size
-  end
-  
-  def test_should_track_events_order
-    assert_equal %w(turn_on activate), @machine.events_order
+    object.state = 'first_gear'
+    object.shift_down
+    assert_equal 'parked', object.state
   end
 end
 
@@ -1026,9 +1020,9 @@ class MachineWithTransitionCallbacksTest < Test::Unit::TestCase
       attr_accessor :callbacks
     end
     
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
-    @event = @machine.event :turn_on do
-      transition :to => 'on', :from => 'off'
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @event = @machine.event :ignite do
+      transition :to => :idling, :from => :parked
     end
     
     @object = @klass.new
@@ -1036,11 +1030,13 @@ class MachineWithTransitionCallbacksTest < Test::Unit::TestCase
   end
   
   def test_should_raise_exception_if_invalid_option_specified
-    assert_raise(ArgumentError) {@machine.before_transition :invalid => true}
+    exception = assert_raise(ArgumentError) {@machine.before_transition :invalid => true, :do => lambda {}}
+    assert_equal 'Invalid key(s): invalid', exception.message
   end
   
   def test_should_raise_exception_if_do_option_not_specified
-    assert_raise(ArgumentError) {@machine.before_transition :to => 'on'}
+    exception = assert_raise(ArgumentError) {@machine.before_transition :to => :idling}
+    assert_equal ':do callback must be specified', exception.message
   end
   
   def test_should_invoke_callbacks_during_transition
@@ -1052,142 +1048,70 @@ class MachineWithTransitionCallbacksTest < Test::Unit::TestCase
   end
   
   def test_should_support_from_requirement
-    @machine.before_transition :from => 'off', :do => lambda {|object| object.callbacks << 'off'}
-    @machine.before_transition :from => 'on', :do => lambda {|object| object.callbacks << 'on'}
+    @machine.before_transition :from => :parked, :do => lambda {|object| object.callbacks << :parked}
+    @machine.before_transition :from => :idling, :do => lambda {|object| object.callbacks << :idling}
     
     @event.fire(@object)
-    assert_equal %w(off), @object.callbacks
+    assert_equal [:parked], @object.callbacks
   end
   
   def test_should_support_except_from_requirement
-    @machine.before_transition :except_from => 'off', :do => lambda {|object| object.callbacks << 'off'}
-    @machine.before_transition :except_from => 'on', :do => lambda {|object| object.callbacks << 'on'}
+    @machine.before_transition :except_from => :parked, :do => lambda {|object| object.callbacks << :parked}
+    @machine.before_transition :except_from => :idling, :do => lambda {|object| object.callbacks << :idling}
     
     @event.fire(@object)
-    assert_equal %w(on), @object.callbacks
+    assert_equal [:idling], @object.callbacks
   end
   
   def test_should_support_to_requirement
-    @machine.before_transition :to => 'off', :do => lambda {|object| object.callbacks << 'off'}
-    @machine.before_transition :to => 'on', :do => lambda {|object| object.callbacks << 'on'}
+    @machine.before_transition :to => :parked, :do => lambda {|object| object.callbacks << :parked}
+    @machine.before_transition :to => :idling, :do => lambda {|object| object.callbacks << :idling}
     
     @event.fire(@object)
-    assert_equal %w(on), @object.callbacks
+    assert_equal [:idling], @object.callbacks
   end
   
   def test_should_support_except_to_requirement
-    @machine.before_transition :except_to => 'off', :do => lambda {|object| object.callbacks << 'off'}
-    @machine.before_transition :except_to => 'on', :do => lambda {|object| object.callbacks << 'on'}
+    @machine.before_transition :except_to => :parked, :do => lambda {|object| object.callbacks << :parked}
+    @machine.before_transition :except_to => :idling, :do => lambda {|object| object.callbacks << :idling}
     
     @event.fire(@object)
-    assert_equal %w(off), @object.callbacks
+    assert_equal [:parked], @object.callbacks
   end
   
   def test_should_support_on_requirement
-    @machine.before_transition :on => 'turn_off', :do => lambda {|object| object.callbacks << 'turn_off'}
-    @machine.before_transition :on => 'turn_on', :do => lambda {|object| object.callbacks << 'turn_on'}
+    @machine.before_transition :on => :park, :do => lambda {|object| object.callbacks << :park}
+    @machine.before_transition :on => :ignite, :do => lambda {|object| object.callbacks << :ignite}
     
     @event.fire(@object)
-    assert_equal %w(turn_on), @object.callbacks
+    assert_equal [:ignite], @object.callbacks
   end
   
   def test_should_support_except_on_requirement
-    @machine.before_transition :except_on => 'turn_off', :do => lambda {|object| object.callbacks << 'turn_off'}
-    @machine.before_transition :except_on => 'turn_on', :do => lambda {|object| object.callbacks << 'turn_on'}
+    @machine.before_transition :except_on => :park, :do => lambda {|object| object.callbacks << :park}
+    @machine.before_transition :except_on => :ignite, :do => lambda {|object| object.callbacks << :ignite}
     
     @event.fire(@object)
-    assert_equal %w(turn_off), @object.callbacks
+    assert_equal [:park], @object.callbacks
   end
   
   def test_should_track_states_defined_in_transition_callbacks
-    @machine.before_transition :from => 'off', :to => 'on', :do => lambda {}
-    @machine.after_transition :from => 'unknown', :to => 'error', :do => lambda {}
+    @machine.before_transition :from => :parked, :to => :idling, :do => lambda {}
+    @machine.after_transition :from => :first_gear, :to => :second_gear, :do => lambda {}
     
-    assert_equal %w(error off on unknown), @machine.states.keys.sort
+    assert_equal [:parked, :idling, :first_gear, :second_gear], @machine.states.map {|state| state.name}
   end
   
   def test_should_not_duplicate_states_defined_in_multiple_event_transitions
-    @machine.before_transition :from => 'off', :to => 'on', :do => lambda {}
-    @machine.after_transition :from => 'unknown', :to => 'error', :do => lambda {}
-    @machine.after_transition :from => 'off', :to => 'on', :do => lambda {}
+    @machine.before_transition :from => :parked, :to => :idling, :do => lambda {}
+    @machine.after_transition :from => :first_gear, :to => :second_gear, :do => lambda {}
+    @machine.after_transition :from => :parked, :to => :idling, :do => lambda {}
     
-    assert_equal %w(error off on unknown), @machine.states.keys.sort
+    assert_equal [:parked, :idling, :first_gear, :second_gear], @machine.states.map {|state| state.name}
   end
   
   def test_should_define_predicates_for_each_state
-    [:on?, :off?].each {|predicate| assert @object.respond_to?(predicate)}
-  end
-  
-  def test_should_order_states_after_initial_state
-    @machine.before_transition :to => 'unknown', :do => lambda {}
-    assert_equal %w(off on unknown), @machine.states_order
-  end
-  
-  def test_should_order_states_after_transition_states
-    @machine.before_transition :to => 'unknown', :do => lambda {}
-    @machine.event :turn_on do
-      transition :to => 'error'
-    end
-    assert_equal %w(off on error unknown), @machine.states_order
-  end
-  
-  def test_should_order_states_after_states_with_behaviors
-    @machine.before_transition :to => 'unknown', :do => lambda {}
-    @machine.state 'error' do
-      def color
-        'red'
-      end
-    end
-    assert_equal %w(off on error unknown), @machine.states_order
-  end
-  
-  def test_should_order_states_after_other_states
-    @machine.before_transition :to => 'unknown', :do => lambda {}
-    @machine.other_states 'error'
-    assert_equal %w(off on error unknown), @machine.states_order
-  end
-end
-
-class MachineWithOtherStates < Test::Unit::TestCase
-  def setup
-    @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
-    @machine.other_states('off', 'on')
-  end
-  
-  def test_should_include_other_states_in_known_states
-    assert_equal %w(off on), @machine.states.keys.sort
-  end
-  
-  def test_should_define_predicates_for_each_state
-    object = @klass.new
-    
-    [:on?, :off?].each {|predicate| assert object.respond_to?(predicate)}
-  end
-  
-  def test_should_order_states_after_initial_state
-    assert_equal %w(off on), @machine.states_order
-  end
-  
-  def test_should_order_states_after_transition_states
-    @machine.event :turn_on do
-      transition :to => 'error'
-    end
-    assert_equal %w(off error on), @machine.states_order
-  end
-  
-  def test_should_order_states_after_states_with_behaviors
-    @machine.state 'error' do
-      def color
-        'red'
-      end
-    end
-    assert_equal %w(off error on), @machine.states_order
-  end
-  
-  def test_should_order_state_before_callback_states
-    @machine.before_transition :to => 'error', :do => lambda {}
-    assert_equal %w(off on error), @machine.states_order
+    [:parked?, :idling?].each {|predicate| assert @object.respond_to?(predicate)}
   end
 end
 
@@ -1210,63 +1134,63 @@ end
 class MachineWithExistingMachinesOnOwnerClassTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
-    @second_machine = StateMachine::Machine.new(@klass, 'status', :initial => 'active')
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @second_machine = StateMachine::Machine.new(@klass, :status, :initial => :idling)
     @object = @klass.new
   end
   
   def test_should_track_each_state_machine
-    expected = {'state' => @machine, 'status' => @second_machine}
+    expected = {:state => @machine, :status => @second_machine}
     assert_equal expected, @klass.state_machines
   end
   
   def test_should_initialize_state_for_both_machines
-    assert_equal 'off', @object.state
-    assert_equal 'active', @object.status
+    assert_equal 'parked', @object.state
+    assert_equal 'idling', @object.status
   end
 end
 
 class MachineWithNamespaceTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, :namespace => 'switch', :initial => 'off') do
-      event :turn_on do
-        transition :to => 'on', :from => 'off'
+    @machine = StateMachine::Machine.new(@klass, :namespace => 'car', :initial => :parked) do
+      event :ignite do
+        transition :to => :idling, :from => :parked
       end
       
-      event :turn_off do
-        transition :to => 'off', :from => 'on'
+      event :park do
+        transition :to => :parked, :from => :idling
       end
     end
     @object = @klass.new
   end
   
   def test_should_namespace_state_predicates
-    [:switch_off?, :switch_on?].each do |name|
+    [:car_parked?, :car_idling?].each do |name|
       assert @object.respond_to?(name)
     end
   end
   
   def test_should_namespace_event_checks
-    [:can_turn_on_switch?, :can_turn_off_switch?].each do |name|
+    [:can_ignite_car?, :can_park_car?].each do |name|
       assert @object.respond_to?(name)
     end
   end
   
   def test_should_namespace_event_transition_readers
-    [:next_turn_on_switch_transition, :next_turn_off_switch_transition].each do |name|
+    [:next_ignite_car_transition, :next_park_car_transition].each do |name|
       assert @object.respond_to?(name)
     end
   end
   
   def test_should_namespace_events
-    [:turn_on_switch, :turn_off_switch].each do |name|
+    [:ignite_car, :park_car].each do |name|
       assert @object.respond_to?(name)
     end
   end
   
   def test_should_namespace_bang_events
-    [:turn_on_switch!, :turn_off_switch!].each do |name|
+    [:ignite_car!, :park_car!].each do |name|
       assert @object.respond_to?(name)
     end
   end
@@ -1292,7 +1216,7 @@ class MachineFinderWithoutExistingMachineTest < Test::Unit::TestCase
   end
   
   def test_should_use_default_state
-    assert_equal 'state', @machine.attribute
+    assert_equal :state, @machine.attribute
   end
 end
 
@@ -1327,13 +1251,13 @@ class MachineFinderWithExistingMachineOnSuperclassTest < Test::Unit::TestCase
     StateMachine::Integrations.const_set('Custom', integration)
     
     @base_class = Class.new
-    @base_machine = StateMachine::Machine.new(@base_class, 'status', :action => :save, :integration => :custom)
-    @base_machine.event(:turn_on) {}
+    @base_machine = StateMachine::Machine.new(@base_class, :status, :action => :save, :integration => :custom)
+    @base_machine.event(:ignite) {}
     @base_machine.before_transition(lambda {})
     @base_machine.after_transition(lambda {})
     
     @klass = Class.new(@base_class)
-    @machine = StateMachine::Machine.find_or_create(@klass, 'status')
+    @machine = StateMachine::Machine.find_or_create(@klass, :status)
   end
   
   def test_should_accept_a_block
@@ -1351,7 +1275,7 @@ class MachineFinderWithExistingMachineOnSuperclassTest < Test::Unit::TestCase
   end
   
   def test_should_copy_the_base_attribute
-    assert_equal 'status', @machine.attribute
+    assert_equal :status, @machine.attribute
   end
   
   def test_should_copy_the_base_configuration
@@ -1360,7 +1284,7 @@ class MachineFinderWithExistingMachineOnSuperclassTest < Test::Unit::TestCase
   
   def test_should_copy_events
     # Can't assert equal arrays since their machines change
-    assert_equal 1, @machine.events.size
+    assert_equal 1, @machine.events.length
   end
   
   def test_should_copy_before_callbacks
@@ -1383,16 +1307,16 @@ end
 class MachineFinderCustomOptionsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
-    @machine = StateMachine::Machine.find_or_create(@klass, 'status', :initial => 'off')
+    @machine = StateMachine::Machine.find_or_create(@klass, :status, :initial => :parked)
     @object = @klass.new
   end
   
   def test_should_use_custom_attribute
-    assert_equal 'status', @machine.attribute
+    assert_equal :status, @machine.attribute
   end
   
   def test_should_set_custom_initial_state
-    assert_equal 'off', @machine.initial_state(@object)
+    assert_equal :parked, @machine.initial_state(@object).name
   end
 end
 
@@ -1406,9 +1330,9 @@ begin
       @klass = Class.new do
         def self.name; 'Vehicle'; end
       end
-      @machine = StateMachine::Machine.new(@klass)
+      @machine = StateMachine::Machine.new(@klass, :initial => :parked)
       @machine.event :ignite do
-        transition :from => 'parked', :to => 'idling'
+        transition :to => :idling, :from => :parked
       end
     end
     
@@ -1450,10 +1374,12 @@ begin
       @klass = Class.new do
         def self.name; 'Vehicle'; end
       end
-      @machine = StateMachine::Machine.new(@klass, :state_id)
+      @machine = StateMachine::Machine.new(@klass, :state_id, :initial => :parked)
       @machine.event :ignite do
-        transition :from => 2, :to => 1
+        transition :to => :idling, :from => :parked
       end
+      @machine.state :parked, :value => 1
+      @machine.state :idling, :value => 2
       @machine.draw
     end
     
@@ -1469,17 +1395,18 @@ begin
       @klass = Class.new do
         def self.name; 'Vehicle'; end
       end
-      @machine = StateMachine::Machine.new(@klass, :activated_at, :initial => 'inactive')
-      @machine.event :activate do
-        transition :from => nil, :to => 'active'
+      @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+      @machine.event :ignite do
+        transition :to => :idling, :from => :parked
       end
+      @machine.state :parked, :value => nil
       @machine.draw
     end
     
     def test_should_draw_machine
-      assert File.exist?('./Vehicle_activated_at.png')
+      assert File.exist?('./Vehicle_state.png')
     ensure
-      FileUtils.rm('./Vehicle_activated_at.png')
+      FileUtils.rm('./Vehicle_state.png')
     end
   end
   
@@ -1488,17 +1415,18 @@ begin
       @klass = Class.new do
         def self.name; 'Vehicle'; end
       end
-      @machine = StateMachine::Machine.new(@klass, :activated_at, :initial => 'inactive')
+      @machine = StateMachine::Machine.new(@klass, :initial => :parked)
       @machine.event :activate do
-        transition :from => 'inactive', :to => lambda {Time.now}
+        transition :to => :idling, :from => :parked
       end
+      @machine.state :idling, :value => lambda {Time.now}
       @machine.draw
     end
     
     def test_should_draw_machine
-      assert File.exist?('./Vehicle_activated_at.png')
+      assert File.exist?('./Vehicle_state.png')
     ensure
-      FileUtils.rm('./Vehicle_activated_at.png')
+      FileUtils.rm('./Vehicle_state.png')
     end
   end
   
@@ -1509,12 +1437,13 @@ begin
       end
       @machine = StateMachine::Machine.new(@klass)
       @machine.event :ignite do
-        transition :from => 'parked', :to => 'idling'
+        transition :to => :idling, :from => :parked
       end
     end
     
     def test_should_raise_exception_if_no_class_names_specified
-      assert_raise(ArgumentError) {StateMachine::Machine.draw(nil)}
+      exception = assert_raise(ArgumentError) {StateMachine::Machine.draw(nil)}
+      assert_equal 'At least one class must be specified', exception.message
     end
     
     def test_should_load_files
@@ -1532,5 +1461,5 @@ begin
     end
   end
 rescue LoadError
-  $stderr.puts 'Skipping GraphViz tests. `gem install ruby-graphviz` and try again.'
+  $stderr.puts 'Skipping GraphViz StateMachine::Machine tests. `gem install ruby-graphviz` and try again.'
 end