state_machine 0.4.1 → 0.4.2

data/test/unit/event_test.rb

@@ -400,3 +400,38 @@ class EventWithMultipleTransitionsTest < Test::Unit::TestCase
     assert_equal 'on', @object.state
   end
 end
+
+begin
+  # Load library
+  require 'rubygems'
+  require 'graphviz'
+  
+  class EventDrawingTest < Test::Unit::TestCase
+    def setup
+      states = %w(parked idling first_gear)
+      
+      @machine = StateMachine::Machine.new(Class.new, :initial => 'parked')
+      @machine.other_states(states)
+      
+      graph = GraphViz.new('G')
+      states.each {|state| graph.add_node(state)}
+      
+      @event = StateMachine::Event.new(@machine , 'park')
+      @event.transition :from => 'idling', :to => 'parked'
+      @event.transition :from => 'first_gear', :to => 'parked'
+      @event.transition :except_from => 'parked', :to => 'parked'
+      
+      @edges = @event.draw(graph)
+    end
+    
+    def test_should_generate_edges_for_each_transition
+      assert_equal 4, @edges.size
+    end
+    
+    def test_should_use_event_name_for_edge_label
+      assert_equal 'park', @edges.first['label']
+    end
+  end
+rescue LoadError
+  $stderr.puts 'Skipping GraphViz StateMachine::Guard tests. `gem install ruby-graphviz` and try again.'
+end

data/test/unit/guard_test.rb

@@ -481,3 +481,143 @@ class GuardWithConflictingConditionalsTest < Test::Unit::TestCase
     assert !guard.matches?(@object)
   end
 end
+
+begin
+  # Load library
+  require 'rubygems'
+  require 'graphviz'
+  
+  class GuardDrawingTest < Test::Unit::TestCase
+    def setup
+      @machine = StateMachine::Machine.new(Class.new)
+      states = %w(parked idling)
+      
+      graph = GraphViz.new('G')
+      states.each {|state| graph.add_node(state)}
+      
+      @guard = StateMachine::Guard.new(:from => 'idling', :to => 'parked')
+      @edges = @guard.draw(graph, 'park', states)
+    end
+    
+    def test_should_create_edges
+      assert_equal 1, @edges.size
+    end
+    
+    def test_should_use_from_state_from_start_node
+      assert_equal 'idling', @edges.first.instance_variable_get('@xNodeOne')
+    end
+    
+    def test_should_use_to_state_for_end_node
+      assert_equal 'parked', @edges.first.instance_variable_get('@xNodeTwo')
+    end
+    
+    def test_should_use_event_name_as_label
+      assert_equal 'park', @edges.first['label']
+    end
+  end
+  
+  class GuardDrawingWithFromRequirementTest < Test::Unit::TestCase
+    def setup
+      @machine = StateMachine::Machine.new(Class.new)
+      states = %w(parked idling first_gear)
+      
+      graph = GraphViz.new('G')
+      states.each {|state| graph.add_node(state)}
+      
+      @guard = StateMachine::Guard.new(:from => %w(idling first_gear), :to => 'parked')
+      @edges = @guard.draw(graph, 'park', states)
+    end
+    
+    def test_should_generate_edges_for_each_valid_from_state
+      %w(idling first_gear).each_with_index do |from_state, index|
+        edge = @edges[index]
+        assert_equal from_state, edge.instance_variable_get('@xNodeOne')
+        assert_equal 'parked', edge.instance_variable_get('@xNodeTwo')
+      end
+    end
+  end
+  
+  class GuardDrawingWithExceptFromRequirementTest < Test::Unit::TestCase
+    def setup
+      @machine = StateMachine::Machine.new(Class.new)
+      states = %w(parked idling first_gear)
+      
+      graph = GraphViz.new('G')
+      states.each {|state| graph.add_node(state)}
+      
+      @guard = StateMachine::Guard.new(:except_from => 'parked', :to => 'parked')
+      @edges = @guard.draw(graph, 'park', states)
+    end
+    
+    def test_should_generate_edges_for_each_valid_from_state
+      %w(idling first_gear).each_with_index do |from_state, index|
+        edge = @edges[index]
+        assert_equal from_state, edge.instance_variable_get('@xNodeOne')
+        assert_equal 'parked', edge.instance_variable_get('@xNodeTwo')
+      end
+    end
+  end
+  
+  class GuardDrawingWithoutFromRequirementTest < Test::Unit::TestCase
+    def setup
+      @machine = StateMachine::Machine.new(Class.new)
+      states = %w(parked idling first_gear)
+      
+      graph = GraphViz.new('G')
+      states.each {|state| graph.add_node(state)}
+      
+      @guard = StateMachine::Guard.new(:to => 'parked')
+      @edges = @guard.draw(graph, 'park', states)
+    end
+    
+    def test_should_generate_edges_for_each_valid_from_state
+      %w(parked idling first_gear).each_with_index do |from_state, index|
+        edge = @edges[index]
+        assert_equal from_state, edge.instance_variable_get('@xNodeOne')
+        assert_equal 'parked', edge.instance_variable_get('@xNodeTwo')
+      end
+    end
+  end
+  
+  class GuardDrawingWithoutToRequirementTest < Test::Unit::TestCase
+    def setup
+      @machine = StateMachine::Machine.new(Class.new)
+      
+      graph = GraphViz.new('G')
+      graph.add_node('parked')
+      
+      @guard = StateMachine::Guard.new(:from => 'parked')
+      @edges = @guard.draw(graph, 'park', ['parked'])
+    end
+    
+    def test_should_create_loopback_edge
+      assert_equal 'parked', @edges.first.instance_variable_get('@xNodeOne')
+      assert_equal 'parked', @edges.first.instance_variable_get('@xNodeTwo')
+    end
+  end
+  
+  class GuardWithProcStatesTest < Test::Unit::TestCase
+    def setup
+      @machine = StateMachine::Machine.new(Class.new)
+      @from_state = lambda {}
+      @to_state = lambda {}
+      states = [@from_state, @to_state]
+      
+      graph = GraphViz.new('G')
+      states.each {|state| graph.add_node("lambda#{state.object_id.abs}")}
+      
+      @guard = StateMachine::Guard.new(:from => @from_state, :to => @to_state)
+      @edges = @guard.draw(graph, 'park', states)
+    end
+    
+    def test_should_use_state_id_for_from_state
+      assert_equal "lambda#{@from_state.object_id.abs}", @edges.first.instance_variable_get('@xNodeOne')
+    end
+    
+    def test_should_use_state_id_for_to_state
+      assert_equal "lambda#{@to_state.object_id.abs}", @edges.first.instance_variable_get('@xNodeTwo')
+    end
+  end
+rescue LoadError
+  $stderr.puts 'Skipping GraphViz StateMachine::Guard tests. `gem install ruby-graphviz` and try again.'
+end

data/test/unit/integrations/active_record_test.rb

@@ -341,7 +341,7 @@ begin
       def test_should_include_transition_states_in_known_states
         @machine.before_transition :to => 'error', :do => lambda {}
         
-        assert_equal %w(error off), @machine.states.sort
+        assert_equal %w(error off), @machine.states.keys.sort
       end
     end
     
@@ -515,6 +515,39 @@ begin
       end
     end
     
+    class MachineWithNamespacedObserversTest < ActiveRecord::TestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :namespace => 'switch')
+        @record = @model.new(:state => 'off')
+        @transition = StateMachine::Transition.new(@record, @machine, 'turn_on', 'off', 'on')
+      end
+      
+      def test_should_call_namespaced_before_event_method
+        observer = new_observer(@model) do
+          def before_turn_on_switch(*args)
+            notifications << args
+          end
+        end
+        instance = observer.instance
+        
+        @transition.perform
+        assert_equal [[@record, @transition]], instance.notifications
+      end
+      
+      def test_should_call_namespaced_after_event_method
+        observer = new_observer(@model) do
+          def after_turn_on_switch(*args)
+            notifications << args
+          end
+        end
+        instance = observer.instance
+        
+        @transition.perform
+        assert_equal [[@record, @transition]], instance.notifications
+      end
+    end
+    
     class MachineWithMixedCallbacksTest < ActiveRecord::TestCase
       def setup
         @model = new_model

data/test/unit/machine_test.rb

@@ -36,7 +36,11 @@ class MachineByDefaultTest < Test::Unit::TestCase
   end
   
   def test_should_have_a_nil_state
-    assert_equal [nil], @machine.states
+    assert_equal [nil], @machine.states.keys
+  end
+  
+  def test_should_set_initial_on_nil_state
+    assert @machine.state(nil).initial
   end
   
   def test_should_not_be_extended_by_the_active_record_integration
@@ -122,6 +126,7 @@ class MachineWithStaticInitialStateTest < Test::Unit::TestCase
     @klass = Class.new do
       def initialize(attributes = {})
         attributes.each {|attr, value| send("#{attr}=", value)}
+        super()
       end
     end
     
@@ -133,6 +138,10 @@ class MachineWithStaticInitialStateTest < Test::Unit::TestCase
     assert_equal 'off', @machine.initial_state(object)
   end
   
+  def test_should_set_initial_on_state_object
+    assert @machine.state('off').initial
+  end
+  
   def test_should_set_initial_state_if_existing_is_nil
     object = @klass.new(:state => nil)
     assert_equal 'off', object.state
@@ -149,7 +158,33 @@ class MachineWithStaticInitialStateTest < Test::Unit::TestCase
   end
   
   def test_should_be_included_in_known_states
-    assert_equal %w(off), @machine.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
   end
 end
 
@@ -176,7 +211,7 @@ class MachineWithDynamicInitialStateTest < Test::Unit::TestCase
   end
   
   def test_should_be_included_in_known_states
-    assert_equal [@initial_state], @machine.states
+    assert_equal [@initial_state], @machine.states.keys
   end
 end
 
@@ -314,7 +349,7 @@ end
 
 class MachineAfterBeingCopiedTest < Test::Unit::TestCase
   def setup
-    @machine = StateMachine::Machine.new(Class.new, 'state')
+    @machine = StateMachine::Machine.new(Class.new, 'state', :initial => 'off')
     @machine.event(:turn_on) {}
     @machine.before_transition(lambda {})
     @machine.after_transition(lambda {})
@@ -327,6 +362,18 @@ class MachineAfterBeingCopiedTest < Test::Unit::TestCase
     assert_not_same @copied_machine.states, @machine.states
   end
   
+  def test_should_copy_each_state
+    assert_not_same @copied_machine.states['off'], @machine.states['off']
+  end
+  
+  def test_should_update_machine_for_each_state
+    assert_equal @copied_machine, @copied_machine.states['off'].machine
+  end
+  
+  def test_should_not_update_machine_for_original_state
+    assert_equal @machine, @machine.states['off'].machine
+  end
+  
   def test_should_not_have_the_same_collection_of_events
     assert_not_same @copied_machine.events, @machine.events
   end
@@ -343,6 +390,10 @@ class MachineAfterBeingCopiedTest < Test::Unit::TestCase
     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
+  end
+  
   def test_should_not_have_the_same_callbacks
     assert_not_same @copied_machine.callbacks, @machine.callbacks
   end
@@ -379,9 +430,16 @@ 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
@@ -495,28 +553,6 @@ class MachineWithConflictingPrivateAttributeAccessorsTest < Test::Unit::TestCase
   end
 end
 
-class MachineWithConflictingStatePredicatesTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new do
-      def on?
-        true
-      end
-      
-      def off?
-        true
-      end
-    end
-    @machine = StateMachine::Machine.new(@klass)
-    @machine.before_transition :to => 'on', :from => 'off', :do => lambda {}
-    @object = @klass.new
-  end
-  
-  def test_should_not_define_state_predicates
-    assert @object.on?
-    assert @object.off?
-  end
-end
-
 class MachineWithConflictingScopesTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
@@ -591,9 +627,13 @@ class MachineWithEventsTest < Test::Unit::TestCase
   end
   
   def test_should_have_events
-    @machine.event(:turn_on) {}
+    @machine.event(:turn_on)
     assert_equal %w(turn_on), @machine.events.keys
   end
+  
+  def test_should_return_the_created_event
+    assert_instance_of StateMachine::Event, @machine.event(:turn_on)
+  end
 end
 
 class MachineWithConflictingPredefinedInitializeTest < Test::Unit::TestCase
@@ -605,6 +645,7 @@ class MachineWithConflictingPredefinedInitializeTest < Test::Unit::TestCase
       def initialize
         @initialized = true
         @block_given = block_given?
+        super()
       end
     end
     
@@ -640,6 +681,7 @@ class MachineWithConflictingPostdefinedInitializeTest < Test::Unit::TestCase
       def initialize
         @initialized = true
         @block_given = block_given?
+        super()
       end
     end
     
@@ -776,6 +818,23 @@ class MachineWithConflictingPostdefinedAndSuperclassInitializeTest < Test::Unit:
   end
 end
 
+class MachineWithCustomStateMachineInitializationTest < Test::Unit::TestCase
+  def setup
+    @superclass = Class.new do
+      def initialize
+        initialize_state_machines
+      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
+  end
+end
+
 class MachineWithConflictingMethodAddedTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
@@ -817,16 +876,52 @@ class MachineWithExistingAttributeValue < Test::Unit::TestCase
   end
 end
 
+class MachineWithStateDrivenBehaviorsTest < Test::Unit::TestCase
+  def setup
+    @machine = StateMachine::Machine.new(Class.new, :initial => 'off')
+    @machine.state 'on' do
+      def color
+        'green'
+      end
+    end
+  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_before_other_states
+    @machine.other_states 'error'
+    assert_equal %w(off on error), @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
+  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(:turn_on)
+    @same_event = @machine.event(:turn_on)
   end
   
   def test_should_not_create_new_event
     assert_same @event, @same_event
   end
+  
+  def test_should_allow_accessing_event_without_block
+    assert_equal @event, @machine.event(:turn_on)
+  end
 end
 
 class MachineWithEventsWithTransitionsTest < Test::Unit::TestCase
@@ -844,7 +939,7 @@ class MachineWithEventsWithTransitionsTest < Test::Unit::TestCase
   end
   
   def test_should_track_states_defined_in_event_transitions
-    assert_equal %w(error off on unknown), @machine.states.sort
+    assert_equal %w(error off on unknown), @machine.states.keys.sort
   end
   
   def test_should_not_duplicate_states_defined_in_multiple_event_transitions
@@ -852,7 +947,7 @@ class MachineWithEventsWithTransitionsTest < Test::Unit::TestCase
       transition :to => 'off', :from => 'on'
     end
     
-    assert_equal %w(error off on unknown), @machine.states.sort
+    assert_equal %w(error off on unknown), @machine.states.keys.sort
   end
   
   def test_should_track_state_from_new_events
@@ -861,61 +956,67 @@ class MachineWithEventsWithTransitionsTest < Test::Unit::TestCase
       transition :to => 'maybe'
     end
     
-    assert_equal %w(error maybe off on unknown), @machine.states.sort
+    assert_equal %w(error maybe off on unknown), @machine.states.keys.sort
   end
   
-  def test_should_define_predicates_for_each_state
-    object = @klass.new
-    
-    [:on?, :off?, :error?, :unknown?].each {|predicate| assert object.respond_to?(predicate)}
+  def test_should_order_states_after_initial_state
+    assert_equal %w(off on error unknown), @machine.states_order
   end
-end
-
-class MachineWithSymbolStatesTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass)
-    @machine.event(:turn_on) do
-      transition :to => :on, :from => :off
+  
+  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_define_predicates_for_each_state
-    object = @klass.new
-    
-    [:on?, :off?].each {|predicate| assert object.respond_to?(predicate)}
+  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
   end
 end
 
-class MachineWithNumericStatesTest < Test::Unit::TestCase
+class MachineWithMultipleEventsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass)
-    @machine.event(:turn_on) do
-      transition :to => 1, :from => 2
+    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
+    @result = @machine.event(:turn_on, :activate) do
+      transition :to => 'on', :from => 'off'
     end
   end
   
-  def test_should_not_define_predicates_for_each_state
+  def test_should_have_events
+    assert_equal %w(activate turn_on), @machine.events.keys.sort
+  end
+  
+  def test_should_define_transitions_for_each_event
+    [:turn_on, :activate].each {|event| assert_equal 1, @machine.event(event).guards.size}
+  end
+  
+  def test_should_transition_the_same_for_each_event
     object = @klass.new
+    object.turn_on
+    assert_equal 'on', object.state
     
-    ['1?', '2?'].each {|predicate| assert !object.respond_to?(predicate)}
+    object = @klass.new
+    object.activate
+    assert_equal 'on', object.state
   end
-end
-
-class MachineWithNilStatesTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass)
-    @machine.event(:turn_on) do
-      transition :to => 'on', :from => nil
-    end
+  
+  def test_should_return_all_created_events
+    assert_instance_of Array, @result
+    assert_equal 2, @result.size
   end
   
-  def test_should_not_redefine_nil_predicate
-    object = @klass.new
-    assert !object.nil?
-    assert !object.respond_to?('?')
+  def test_should_track_events_order
+    assert_equal %w(turn_on activate), @machine.events_order
   end
 end
 
@@ -1002,7 +1103,7 @@ class MachineWithTransitionCallbacksTest < Test::Unit::TestCase
     @machine.before_transition :from => 'off', :to => 'on', :do => lambda {}
     @machine.after_transition :from => 'unknown', :to => 'error', :do => lambda {}
     
-    assert_equal %w(error off on unknown), @machine.states.sort
+    assert_equal %w(error off on unknown), @machine.states.keys.sort
   end
   
   def test_should_not_duplicate_states_defined_in_multiple_event_transitions
@@ -1010,23 +1111,52 @@ class MachineWithTransitionCallbacksTest < Test::Unit::TestCase
     @machine.after_transition :from => 'unknown', :to => 'error', :do => lambda {}
     @machine.after_transition :from => 'off', :to => 'on', :do => lambda {}
     
-    assert_equal %w(error off on unknown), @machine.states.sort
+    assert_equal %w(error off on unknown), @machine.states.keys.sort
   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 => 'on')
-    @machine.other_states('on', 'off')
+    @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.sort
+    assert_equal %w(off on), @machine.states.keys.sort
   end
   
   def test_should_define_predicates_for_each_state
@@ -1034,6 +1164,31 @@ class MachineWithOtherStates < Test::Unit::TestCase
     
     [: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
+  end
 end
 
 class MachineWithOwnerSubclassTest < Test::Unit::TestCase
@@ -1071,6 +1226,52 @@ class MachineWithExistingMachinesOnOwnerClassTest < Test::Unit::TestCase
   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'
+      end
+      
+      event :turn_off do
+        transition :to => 'off', :from => 'on'
+      end
+    end
+    @object = @klass.new
+  end
+  
+  def test_should_namespace_state_predicates
+    [:switch_off?, :switch_on?].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|
+      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|
+      assert @object.respond_to?(name)
+    end
+  end
+  
+  def test_should_namespace_events
+    [:turn_on_switch, :turn_off_switch].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|
+      assert @object.respond_to?(name)
+    end
+  end
+end
+
 class MachineFinderWithoutExistingMachineTest < Test::Unit::TestCase
   def setup
     @klass = Class.new