testability-driver-qt-sut-plugin 1.1.1 → 1.2.0

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/behaviours/attribute.rb

@@ -240,11 +240,11 @@ module MobyBehaviour
 			    begin 
 				  returnValue = @sut.execute_command( command )
 				rescue
-				  $logger.log "behaviour" , "FAIL;Failed when calling method set_attribute with values attribute:#{attribute.to_s} value:#{value.to_s}.;#{identity};set_attribute;"
+				  $logger.behaviour "FAIL;Failed when calling method set_attribute with values attribute:#{attribute.to_s} value:#{value.to_s}.;#{identity};set_attribute;"
 				  Kernel::raise RuntimeError.new("Setting attribute '%s' to value '%s' failed with error: %s" % [attribute, value, returnValue])
 				end
 			  
-			    $logger.log "behaviour" , "PASS;The method set_attribute was executed successfully with with values attribute:#{attribute.to_s} value:#{value.to_s}.;#{identity};set_attribute;"
+			    $logger.behaviour "PASS;The method set_attribute was executed successfully with with values attribute:#{attribute.to_s} value:#{value.to_s}.;#{identity};set_attribute;"
 	  
 			    nil
 

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/behaviours/behaviour.rb

@@ -57,7 +57,7 @@ module MobyBehaviour
       # should this method be private?
       def command_params( command = MobyCommand::WidgetCommand.new )   
 
-        if self.attribute( 'objectType' ) == 'Graphics' and self.attribute( 'visibleOnScreen' ) == 'false' and self.creation_attributes[:visibleOnScreen] != 'false'
+        if attribute( 'objectType' ) == 'Graphics' and attribute( 'visibleOnScreen' ) == 'false' and self.creation_attributes[:visibleOnScreen] != 'false'
           begin
             self.creation_attributes.merge!({'visibleOnScreen' => 'true'})
             self.parent.child(self.creation_attributes)
@@ -66,36 +66,36 @@ module MobyBehaviour
           end
         end
 
-        command.set_event_type($parameters[ @sut.id ][ :event_type, "0" ])
+        command.set_event_type(sut_parameters[ :event_type, "0" ])
 
         #for components with object visible on screen but not actual widgets or graphicsitems
-        if self.attribute( 'objectType' ) == 'Embedded'
+        if attribute( 'objectType' ) == 'Embedded'
           command.application_id( get_application_id )
-          command.object_id( parent.id )
+          command.set_object_id( parent.id )
           command.object_type( parent.attribute( 'objectType' ).intern )
         else
           command.application_id( get_application_id )
-          command.object_id( self.id )
-          command.object_type( self.attribute( 'objectType' ).intern )
+          command.set_object_id( @id )
+          command.object_type( attribute( 'objectType' ).intern )
         end
 
         command
 
       end
 
+    private   
+
       # == nodoc
       # should this method be private?
       def plugin_command( require_response = false, command = MobyCommand::WidgetCommand.new )
-        command.set_event_type($parameters[ @sut.id ][ :event_type, "0" ])
+        command.set_event_type(sut_parameters[ :event_type, "0" ])
         command.application_id( get_application_id )
-        command.object_id( self.id )
-        command.object_type( self.attribute('objectType' ).intern)
+        command.set_object_id( @id )
+        command.object_type( attribute('objectType' ).intern)
         command.transitions_off    
         command
       end
 
-    private   
-
       def do_sleep(time)
 
         time = time.to_f * 1.3
@@ -109,23 +109,23 @@ module MobyBehaviour
 
       def center_x
 
-        #x = self.attribute( 'x_absolute' ).to_i
-        #width = self.attribute( 'width' ).to_i
+        #x = attribute( 'x_absolute' ).to_i
+        #width = attribute( 'width' ).to_i
         #x = x + ( width/2 )
         #x.to_s
 
-        ( ( self.attribute( 'x_absolute' ).to_i ) + ( self.attribute( 'width' ).to_i / 2 ) ).to_s
+        ( ( attribute( 'x_absolute' ).to_i ) + ( attribute( 'width' ).to_i / 2 ) ).to_s
 
       end
 
       def center_y
 
-        #y = self.attribute( 'y_absolute' ).to_i
-        #height = self.attribute( 'height' ).to_i
+        #y = attribute( 'y_absolute' ).to_i
+        #height = attribute( 'height' ).to_i
         #y = y + ( height/2 )
         #y.to_s
 
-        ( ( self.attribute( 'y_absolute' ).to_i ) + ( self.attribute( 'height' ).to_i / 2 ) ).to_s
+        ( ( attribute( 'y_absolute' ).to_i ) + ( attribute( 'height' ).to_i / 2 ) ).to_s
 
       end  
 

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/behaviours/configure_behaviour.rb

@@ -227,12 +227,12 @@ module MobyBehaviour
 
 		    rescue Exception => e
 		      
-		      $logger.log "behaviour" , "FAIL;Failed to enable event logging. With event_list \"#{event_list};log_events"
+		      $logger.behaviour "FAIL;Failed to enable event logging. With event_list \"#{event_list};log_events"
 		      Kernel::raise e        
 
 		    end      
 
-		    $logger.log "behaviour" , "PASS;Event logging enabled. With event_list \"#{event_list};log_events"
+		    $logger.behaviour "PASS;Event logging enabled. With event_list \"#{event_list};log_events"
 
 	    end
 
@@ -252,12 +252,12 @@ module MobyBehaviour
 
 		    rescue Exception => e
 		      
-		      $logger.log "behaviour" , "FAIL;Failed to stop event logging.;stop_event_logging"
+		      $logger.behaviour "FAIL;Failed to stop event logging.;stop_event_logging"
 		      Kernel::raise e        
 
 		    end      
 
-		    $logger.log "behaviour" , "PASS;Event logging stopped.;stop_event_logging"
+		    $logger.behaviour "PASS;Event logging stopped.;stop_event_logging"
 
 	    end
 
@@ -287,12 +287,12 @@ module MobyBehaviour
 		      
 		    rescue Exception => e
 		      
-		      $logger.log "behaviour" , "FAIL;Failed to configure logger. With params \"#{params_hash.to_s};configure_logger"
+		      $logger.behaviour "FAIL;Failed to configure logger. With params \"#{params_hash.to_s};configure_logger"
 		      Kernel::raise e        
 
 		    end      
 
-		    $logger.log "behaviour" , "PASS;Succesfully configured logger. With params \"#{params_hash.to_s};configure_logger"
+		    $logger.behaviour "PASS;Succesfully configured logger. With params \"#{params_hash.to_s};configure_logger"
 
 	    end
 

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/behaviours/events.rb

@@ -82,12 +82,12 @@ module MobyBehaviour
 
         rescue Exception => e
 
-          $logger.log "behaviour" , "FAIL;Failed enable_events with refresh \"#{filter_array.to_s}\".;#{ identity };enable_events;"
+          $logger.behaviour "FAIL;Failed enable_events with refresh \"#{filter_array.to_s}\".;#{ identity };enable_events;"
           Kernel::raise e
 
         end
 
-        $logger.log "behaviour" , "PASS;Operation enable_events executed successfully with refresh \"#{ filter_array.to_s }\".;#{ identity };enable_events;"
+        $logger.behaviour "PASS;Operation enable_events executed successfully with refresh \"#{ filter_array.to_s }\".;#{ identity };enable_events;"
         nil
       end
 
@@ -111,11 +111,11 @@ module MobyBehaviour
           command.service( 'collectEvents' )
           @sut.execute_command( command)
         rescue Exception => e
-          $logger.log "behaviour" , "FAIL;Failed disable_events.;#{ identity };disable_events;"
+          $logger.behaviour "FAIL;Failed disable_events.;#{ identity };disable_events;"
           Kernel::raise e 
         end 
 
-        $logger.log "behaviour" , "PASS;Operation disable_events executed successfully.;#{ identity };disable_events;"
+        $logger.behaviour "PASS;Operation disable_events executed successfully.;#{ identity };disable_events;"
         nil
 
       end
@@ -146,12 +146,12 @@ module MobyBehaviour
 
         rescue Exception => e
 
-          $logger.log "behaviour" , "FAIL;Failed get_events.;#{ identity };get_events;"
+          $logger.behaviour "FAIL;Failed get_events.;#{ identity };get_events;"
           Kernel::raise e
     
         end
 
-        $logger.log "behaviour" , "PASS;Operation get_events executed successfully.;#{ identity };get_events;"
+        $logger.behaviour "PASS;Operation get_events executed successfully.;#{ identity };get_events;"
         
         ret
         

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/behaviours/find.rb

@@ -64,11 +64,11 @@ module MobyBehaviour
 				## flick_to (center)
 				search_result.flick_to(window_x.to_i, window_y.to_i)
 			  rescue Exception => e
-				##$logger.log "behaviour" , "FAIL;Failed to find test object.;#{id.to_s};sut;{};find;" << (find_hash.kind_of?(Hash) ? find_hash.inspect : find_hash.class.to_s)  
+				##$logger.behaviour "FAIL;Failed to find test object.;#{id.to_s};sut;{};find;" << (find_hash.kind_of?(Hash) ? find_hash.inspect : find_hash.class.to_s)  
 				## Rescue from center and flick
 				Kernel::raise e
 			  end
-			  $logger.log "behaviour" , "PASS;Test object found and centered.;#{id.to_s};sut;{};application;" << find_hash.inspect  
+			  $logger.behaviour "PASS;Test object found and centered.;#{id.to_s};sut;{};application;" << find_hash.inspect  
 			  search_result
 			end
 

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/behaviours/fixture.rb

@@ -89,22 +89,20 @@ module MobyBehaviour
 		  params = {:name => fixture_name, :command_name => fixture_method, :parameters => parameters_hash, :async => false}
 		  #for sut send the fixture command to qttasserver (appid nil)
 		  if self.class == MobyBase::SUT
-			params.merge!( {:application_id => nil, :object_id => self.id, :object_type => :Application} )
-			ret = self.execute_command( MobyCommand::Fixture.new( params ) )
+			params.merge!( {:application_id => nil, :object_id => @id, :object_type => :Application} )
+			ret = execute_command( MobyCommand::Fixture.new( params ) )
 		  else
-			params.merge!( {:application_id => get_application_id, :object_id => self.id, :object_type => self.attribute( 'objectType' ).intern} )
+			params.merge!( {:application_id => get_application_id, :object_id => @id, :object_type => attribute( 'objectType' ).intern} )
 			ret = @sut.execute_command( MobyCommand::Fixture.new( params ) )
 		  end				  
 		rescue Exception => e
 
-		  $logger.log "behaviour", 
-			"FAIL;Failed when calling fixture with name #{fixture_name} method #{fixture_method} parameters #{parameters_hash.inspect}.;#{id.to_s};sut;{};fixture;"
+		  $logger.behaviour "FAIL;Failed when calling fixture with name #{fixture_name} method #{fixture_method} parameters #{parameters_hash.inspect}.;#{id.to_s};sut;{};fixture;"
 
 		  Kernel::raise MobyBase::BehaviourError.new("Fixture", "Failed to execute fixture name #{fixture_name} method #{fixture_method}")
 		end
 
-		$logger.log "behaviour", 
-		  "PASS;The fixture command was executed successfully with name #{fixture_name} method #{fixture_method} parameters #{parameters_hash.inspect}.;#{id.to_s};sut;{};fixture;"
+		$logger.behaviour "PASS;The fixture command was executed successfully with name #{fixture_name} method #{fixture_method} parameters #{parameters_hash.inspect}.;#{id.to_s};sut;{};fixture;"
 
 		ret
 
@@ -154,22 +152,20 @@ module MobyBehaviour
 		  params = {:name => fixture_name, :command_name => fixture_method, :parameters => parameters_hash, :async => true}
 		  #for sut send the fixture command to qttasserver (appid nil)
 		  if self.class == MobyBase::SUT
-			params.merge!( {:application_id => nil, :object_id => self.id, :object_type => :Application} )
-			ret = self.execute_command( MobyCommand::Fixture.new( params ) )
+			params.merge!( {:application_id => nil, :object_id => @id, :object_type => :Application} )
+			ret = execute_command( MobyCommand::Fixture.new( params ) )
 		  else
-			params.merge!( {:application_id => get_application_id, :object_id => self.id, :object_type => self.attribute( 'objectType' ).intern} )
+			params.merge!( {:application_id => get_application_id, :object_id => @id, :object_type => attribute( 'objectType' ).intern} )
 			ret = @sut.execute_command( MobyCommand::Fixture.new( params ) )
 		  end
 		rescue Exception => e
 
-		  $logger.log "behaviour" , 
-			"FAIL;Failed when calling async_fixture with name #{fixture_name} method #{fixture_method} parameters #{parameters_hash.inspect}.;#{id.to_s};sut;{};fixture;"
+		  $logger.behaviour "FAIL;Failed when calling async_fixture with name #{fixture_name} method #{fixture_method} parameters #{parameters_hash.inspect}.;#{id.to_s};sut;{};fixture;"
 
 		  Kernel::raise MobyBase::BehaviourError.new("Fixture", "Failed to execute async_fixture name #{fixture_name} method #{fixture_method}")
 		end
 
-		$logger.log "behaviour", 
-		  "PASS;The fixture command was executed successfully with name #{fixture_name} method #{fixture_method} parameters #{parameters_hash.inspect}.;#{id.to_s};sut;{};fixture;"
+		$logger.behaviour "PASS;The fixture command was executed successfully with name #{fixture_name} method #{fixture_method} parameters #{parameters_hash.inspect}.;#{id.to_s};sut;{};fixture;"
 
 		ret
 

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/behaviours/fps.rb

@@ -73,12 +73,12 @@ module MobyBehaviour
 		  self.fixture('fps', 'startFps')
 		rescue Exception => e
 
-		  $logger.log "behaviour" , "FAIL;Failed start_fps_measurement.;#{ identity };start_fps_measurement;"
+		  $logger.behaviour "FAIL;Failed start_fps_measurement.;#{ identity };start_fps_measurement;"
 		  Kernel::raise e
 
 		end
 
-		$logger.log "behaviour" , "PASS;Operation start_fps_measurement executed successfully.;#{ identity };start_fps_measurement;"
+		$logger.behaviour "PASS;Operation start_fps_measurement executed successfully.;#{ identity };start_fps_measurement;"
 
 		nil
 	  end
@@ -102,12 +102,12 @@ module MobyBehaviour
 		  results = parse_results( self.fixture('fps', 'stopFps') )
 		rescue Exception => e
 
-		  $logger.log "behaviour" , "FAIL;Failed stop_fps_measurement.;#{ identity };stop_fps_measurement;"
+		  $logger.behaviour "FAIL;Failed stop_fps_measurement.;#{ identity };stop_fps_measurement;"
 		  Kernel::raise e
 
 		end
 
-		$logger.log "behaviour" , "PASS;Operation stop_fps_measurement executed successfully.;#{ identity };stop_fps_measurement;"
+		$logger.behaviour "PASS;Operation stop_fps_measurement executed successfully.;#{ identity };stop_fps_measurement;"
 
 		results
 	  end
@@ -135,12 +135,12 @@ module MobyBehaviour
 		  results = parse_results( self.fixture('fps', 'collectData') )
 		rescue Exception => e
 
-		  $logger.log "behaviour" , "FAIL;Failed collect_fps_data.;#{ identity };collect_fps_data;"
+		  $logger.behaviour "FAIL;Failed collect_fps_data.;#{ identity };collect_fps_data;"
 		  Kernel::raise e
 
 		end
 
-		$logger.log "behaviour" , "PASS;Operation collect_fps_data executed successfully.;#{ identity };collect_fps_data;"
+		$logger.behaviour "PASS;Operation collect_fps_data executed successfully.;#{ identity };collect_fps_data;"
 
 		results
 	  end
@@ -148,7 +148,7 @@ module MobyBehaviour
 	  private
 	  
 	  def parse_results(results_xml)
-		xml_as_object = MobyBase::StateObject.new( results_xml )
+		xml_as_object = @sut.state_object( results_xml )
 		results = []
 		count = xml_as_object.results.attribute('count').to_i
 		for i in 0...count

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/behaviours/gesture.rb

@@ -42,11 +42,11 @@ module MobyBehaviour
     # == objects
     # *
     #
-	  module Gesture
+    module Gesture
 
-	    include MobyBehaviour::QT::Behaviour
+      include MobyBehaviour::QT::Behaviour
 
-	    # == description
+      # == description
       # Flick the screen at the location of the object (touch the object and do a flick gesture).
       # Speed and distance of the flick are defined in the tdriver_parameters under the sut used.
       # By default a flick is a fast gesture.
@@ -81,33 +81,40 @@ module MobyBehaviour
       # == exceptions
       # ArgumentError
       #   description: One of the arguments is not valid  
-	    def flick( direction, button = :Left, optional_params = {} )
+      def flick( direction, button = :Left, optional_params = {} )
+
+      begin
+        
+        if optional_params[:use_tap_screen].nil?
+          use_tap_screen = sut_parameters[ :use_tap_screen, 'false']
+        else
+          use_tap_screen = optional_params[:use_tap_screen].to_s
+        end
 
-		  begin
-            use_tap_screen = optional_params[:use_tap_screen].nil? ? $parameters[ @sut.id][ :use_tap_screen, 'false'] :
-              optional_params[:use_tap_screen].to_s
-            optional_params[:useTapScreen] = use_tap_screen
+        optional_params[:useTapScreen] = use_tap_screen
             
-		    speed = calculate_speed(@sut.parameter[:gesture_flick_distance], @sut.parameter[:gesture_flick_speed])
-		    distance = @sut.parameter[:gesture_flick_distance].to_i
-            params = {:gesture_type => :MouseGesture, :direction => direction, :speed => speed, :distance => distance, :isDrag => false, :button => button, :useTapScreen => use_tap_screen}
-            params.merge!(optional_params)
+        speed = calculate_speed(sut_parameters[:gesture_flick_distance], sut_parameters[:gesture_flick_speed])
+        distance = sut_parameters[:gesture_flick_distance].to_i
+
+        params = {:gesture_type => :MouseGesture, :direction => direction, :speed => speed, :distance => distance, :isDrag => false, :button => button, :useTapScreen => use_tap_screen}
 
-		    do_gesture(params)		
-		    do_sleep(speed)
-		    
-		  rescue Exception => e
+        params.merge!(optional_params)
 
-		    $logger.log "behaviour" , "FAIL;Failed flick with direction \"#{direction}\", button \"#{button.to_s}\".;#{identity};flick;"
-		    Kernel::raise e        
-		  end      
+        do_gesture(params)    
+        do_sleep(speed)
+        
+      rescue Exception => e
 
-		  $logger.log "behaviour" , "PASS;Operation flick executed successfully with direction \"#{direction}\", button \"#{button.to_s}\".;#{identity};flick;"
+        $logger.behaviour "FAIL;Failed flick with direction \"#{direction}\", button \"#{button.to_s}\".;#{identity};flick;"
+        Kernel::raise e        
+      end      
 
-		  self
-	    end
+      $logger.behaviour "PASS;Operation flick executed successfully with direction \"#{direction}\", button \"#{button.to_s}\".;#{identity};flick;"
 
-	    # == description
+      self
+      end
+
+      # == description
       # Flick the screen at the location of the object (touch the object and do a flick gesture), ending the flick at the specified coordinates.
       # Speed and distance of the flick are defined in the tdriver_parameters under the sut used.
       # By default a flick is a fast gesture.
@@ -143,34 +150,50 @@ module MobyBehaviour
       #
       # == exceptions
       # ArgumentError
-      #  description: One of the arguments is not valid  	
-	    def flick_to( x, y, button = :Left, optional_params = {})
+      #  description: One of the arguments is not valid    
+      def flick_to( x, y, button = :Left, optional_params = {})
+
+      begin
+      
+        if optional_params[:use_tap_screen].nil?
+          use_tap_screen = sut_parameters[:use_tap_screen, 'false']
+        else
+          use_tap_screen = optional_params[:use_tap_screen].to_s
+        end
+  
+        optional_params[:useTapScreen] = use_tap_screen
 
-		  begin
-            use_tap_screen = optional_params[:use_tap_screen].nil? ? $parameters[ @sut.id][ :use_tap_screen, 'false'] :
-              optional_params[:use_tap_screen].to_s
-            optional_params[:useTapScreen] = use_tap_screen
+        speed = calculate_speed( sut_parameters[ :gesture_flick_distance ], sut_parameters[ :gesture_flick_speed ] )
 
-		    
+        do_gesture(
+          {
+            :gesture_type => :MouseGestureToCoordinates, 
+            :x => x, 
+            :y => y, 
+            :speed => speed, 
+            :isDrag => false, 
+            :button => button, 
+            :useTapScreen => use_tap_screen
+          }
+        )
+        
+        do_sleep(speed)
 
-		    speed = calculate_speed( @sut.parameter[ :gesture_flick_distance ], @sut.parameter[ :gesture_flick_speed ] )
-		    do_gesture({:gesture_type => :MouseGestureToCoordinates, :x => x, :y => y, :speed => speed, :isDrag => false, :button => button, :useTapScreen => use_tap_screen})		
-		    do_sleep(speed)
+      rescue Exception => e
 
-		  rescue Exception => e
+        $logger.behaviour "FAIL;Failed flick_to with x \"#{x}\", y \"#{y}\", button \"#{button.to_s}\".;#{identity};drag;"
+        Kernel::raise e        
 
-		    $logger.log "behaviour" , "FAIL;Failed flick_to with x \"#{x}\", y \"#{y}\", button \"#{button.to_s}\".;#{identity};drag;"
-		    Kernel::raise e        
-		  end      
+      end      
 
-		  $logger.log "behaviour" , "PASS;Operation flick_to executed successfully with x \"#{x}\", y \"#{y}\", button \"#{button.to_s}\".;#{identity};drag;"
+      $logger.behaviour "PASS;Operation flick_to executed successfully with x \"#{x}\", y \"#{y}\", button \"#{button.to_s}\".;#{identity};drag;"
 
-		  self
+      self
 
-	    end
+      end
 
 
-	    # == description
+      # == description
       # Perform a gesture with the object
       #
       # == arguments
@@ -200,8 +223,8 @@ module MobyBehaviour
       #   default: { :use_tap_screen => 'false', :isDrag => false, :button => :Left }  
       #
       # == tables
-	    # directions_table
-	    #  title: Direction symbols table
+      # directions_table
+      #  title: Direction symbols table
       #  |Symbol|
       #  |:Left|
       #  |:Right|
@@ -209,7 +232,7 @@ module MobyBehaviour
       #  |:Down|
       #
       # buttons_table
-	    #  title: Mouse button symbols table
+      #  title: Mouse button symbols table
       #  |Symbol|Description|
       #  |:Left|Simulate left mouse button|
       #  |:Middle|Simulate middle mouse button|
@@ -224,43 +247,43 @@ module MobyBehaviour
       # == exceptions
       # ArgumentError
       #  description: One of the arguments is not valid    
-	    def gesture( direction, speed, distance, optional_params = {:button => :Left, :isDrag => false}) 
+      def gesture( direction, speed, distance, optional_params = {:button => :Left, :isDrag => false}) 
 
-		  begin
-            # change the format for api consitency
-            use_tap_screen = optional_params[:use_tap_screen].nil? ? $parameters[ @sut.id][ :use_tap_screen, 'false'] :
-              optional_params[:use_tap_screen].to_s
-            optional_params[:useTapScreen] = use_tap_screen
-            optional_params['x_off'] = $parameters[ @sut.id ][:tap_x_offset , '0' ],
-            optional_params['y_off'] = $parameters[ @sut.id ][:tap_y_offset , '0' ]
+      begin
 
+        if optional_params[:use_tap_screen].nil?
+          use_tap_screen = sut_parameters[ :use_tap_screen, 'false']
+        else
+          use_tap_screen = optional_params[:use_tap_screen].to_s
+        end
 
+        optional_params[:useTapScreen] = use_tap_screen
+        optional_params['x_off'] = sut_parameters[:tap_x_offset , '0' ],
+        optional_params['y_off'] = sut_parameters[:tap_y_offset , '0' ]
 
-		    #do_gesture(direction, speed, distance, isDrag, button)
-		    params = {
-		    	:gesture_type => :MouseGesture,
-		    	:direction => direction,
-		    	:speed => speed,
-		    	:distance => distance
-		    }
-		    params.merge!(optional_params)
-		    do_gesture(params)
-		    do_sleep(speed)
+        #do_gesture(direction, speed, distance, isDrag, button)
+        params = {
+          :gesture_type => :MouseGesture,
+          :direction => direction,
+          :speed => speed,
+          :distance => distance
+        }
+        params.merge!(optional_params)
+        do_gesture(params)
+        do_sleep(speed)
 
-		  rescue Exception => e
+      rescue Exception => e
 
-		    $logger.log "behaviour", 
-			  "FAIL;Failed gesture with direction \"#{direction}\", speed \"#{speed.to_s}\", distance \"#{distance.to_s}\".;#{identity};gesture;"
-		    Kernel::raise e        
-		  end      
+        $logger.behaviour "FAIL;Failed gesture with direction \"#{direction}\", speed \"#{speed.to_s}\", distance \"#{distance.to_s}\".;#{identity};gesture;"
+        Kernel::raise e        
+      end      
 
-		  $logger.log "behaviour", 
-		    "PASS;Operation gesture executed successfully with direction \"#{direction}\", speed \"#{speed.to_s}\", distance \"#{distance.to_s}\".;#{identity};gesture;"
+      $logger.behaviour "PASS;Operation gesture executed successfully with direction \"#{direction}\", speed \"#{speed.to_s}\", distance \"#{distance.to_s}\".;#{identity};gesture;"
 
-		  self
-	    end
+      self
+      end
 
-	    # == description
+      # == description
       # Perform a gesture with the object, ending the gesture at the specified point.
       #
       # == arguments
@@ -293,45 +316,49 @@ module MobyBehaviour
       # == exceptions
       # ArgumentError
       #  description: One of the arguments is not valid   
-        def gesture_to(x, y, speed, optional_params = {:button => :Left, :isDrag => false})
-
-          begin      
-            # change the format for api consitency
-            use_tap_screen = optional_params[:use_tap_screen].nil? ? $parameters[ @sut.id][ :use_tap_screen, 'false'] :
-              optional_params[:use_tap_screen].to_s
-            optional_params[:useTapScreen] = use_tap_screen
-
-            params = {:gesture_type => :MouseGestureToCoordinates, :speed => speed}
-            if attribute('objectType') == 'Web'
-              elemens_xml_data, unused_rule = TDriver::TestObjectAdapter.get_objects( @sut.xml_data, { :id => self.attribute('webFrame')}, true )
-              object_xml_data = elemens_xml_data[0]
-              object_attributes = TDriver::TestObjectAdapter.test_object_attributes(object_xml_data, ['x_absolute', 'y_absolute'])
-              frame_x_absolute = object_attributes['x_absolute'].to_i
-              frame_y_absolute = object_attributes['y_absolute'].to_i
-              new_params = {:x=>(frame_x_absolute + x.to_i + (attribute('width' ).to_i/2)),
-                            :y=>(frame_y_absolute + y.to_i + (attribute('height').to_i/2))}
-              params.merge!(new_params)
-            else
-              new_params = {:x=>x, :y=>y}
-              params.merge!(new_params)
-            end
-            
-            
-            params.merge!(optional_params)
-            do_gesture(params)
-            do_sleep(speed) 
+      def gesture_to(x, y, speed, optional_params = {:button => :Left, :isDrag => false})
 
-          rescue Exception => e
+        begin      
 
-            $logger.log "behaviour" , "FAIL;Failed gesture_to with x \"#{x}\", y \"#{y}\", speed \"#{speed.to_s}\", button \".;#{identity};gesture;"
-            Kernel::raise e        
+          if optional_params[:use_tap_screen].nil?
+            use_tap_screen = sut_parameters[ :use_tap_screen, 'false']
+          else
+            use_tap_screen = optional_params[:use_tap_screen].to_s
           end
 
-          $logger.log "behaviour" , "PASS;Operation gesture_to executed successfully with x \"#{x}\", y \"#{y}\", speed \"#{speed.to_s}\".;#{identity};gesture;"
-          self
+          optional_params[:useTapScreen] = use_tap_screen
+
+          params = {:gesture_type => :MouseGestureToCoordinates, :speed => speed}
+          if attribute('objectType') == 'Web'
+            elemens_xml_data, unused_rule = @test_object_adapter.get_objects( @sut.xml_data, { :id => attribute('webFrame')}, true )
+            object_xml_data = elemens_xml_data[0]
+            object_attributes = @test_object_adapter.test_object_attributes(object_xml_data, ['x_absolute', 'y_absolute'])
+            frame_x_absolute = object_attributes['x_absolute'].to_i
+            frame_y_absolute = object_attributes['y_absolute'].to_i
+            new_params = {:x=>(frame_x_absolute + x.to_i + (attribute('width' ).to_i/2)),
+                          :y=>(frame_y_absolute + y.to_i + (attribute('height').to_i/2))}
+            params.merge!(new_params)
+          else
+            new_params = {:x=>x, :y=>y}
+            params.merge!(new_params)
+          end
+          
+          
+          params.merge!(optional_params)
+          do_gesture(params)
+          do_sleep(speed) 
+
+        rescue Exception => e
+
+          $logger.behaviour "FAIL;Failed gesture_to with x \"#{x}\", y \"#{y}\", speed \"#{speed.to_s}\", button \".;#{identity};gesture;"
+          Kernel::raise e        
         end
 
-    	# == description
+        $logger.behaviour "PASS;Operation gesture_to executed successfully with x \"#{x}\", y \"#{y}\", speed \"#{speed.to_s}\".;#{identity};gesture;"
+        self
+      end
+
+      # == description
       # Perform a gesture with the object, starting the gesture at the specified point inside it.
       #
       # == arguments
@@ -379,30 +406,31 @@ module MobyBehaviour
       # ArgumentError
       #  description: One of the arguments is not valid, or the initial point is outside the target object.
       #
-	    def gesture_from(x, y, speed, distance, direction, optional_params = {:button => :Left, :isDrag => false})
-		  begin
-		    raise ArgumentError.new( "Coordinate x:#{x} x_abs:#{x} outside object." ) unless ( x <= attribute( 'width' ).to_i and x >= 0 )
-		    raise ArgumentError.new( "Coordinate y:#{y} y_abs:#{y} outside object." ) unless ( y <= attribute( 'height' ).to_i and y >= 0 )
-		    
-		    x_absolute = attribute('x_absolute').to_i + x.to_i 
-		    y_absolute = attribute('y_absolute').to_i + y.to_i 
+      def gesture_from(x, y, speed, distance, direction, optional_params = {:button => :Left, :isDrag => false})
 
-            params = {:gesture_type => :MouseGestureFromCoordinates, :x => x_absolute, :y => y_absolute, :speed => speed, :distance => distance, :direction => direction}
+        begin
 
-            params.merge!(optional_params)
-		    do_gesture(params)
-		    do_sleep(speed) 
+          raise ArgumentError.new( "Coordinate x:#{x} x_abs:#{x} outside object." ) unless ( x <= attribute( 'width' ).to_i and x >= 0 )
+          raise ArgumentError.new( "Coordinate y:#{y} y_abs:#{y} outside object." ) unless ( y <= attribute( 'height' ).to_i and y >= 0 )
+          
+          x_absolute = attribute('x_absolute').to_i + x.to_i 
+          y_absolute = attribute('y_absolute').to_i + y.to_i 
 
+          params = {:gesture_type => :MouseGestureFromCoordinates, :x => x_absolute, :y => y_absolute, :speed => speed, :distance => distance, :direction => direction}
 
-		  rescue Exception => e      
-		    $logger.log "behaviour" , "FAIL;Failed gesture_from with x \"#{x}\", y \"#{y}\", speed \"#{speed.to_s}\", distance \"#{distance.to_s}\", button \".;#{identity};gesture;"
-		    Kernel::raise e        
-		  end
-		  $logger.log "behaviour" , "PASS;Operation gesture_from executed successfully with x \"#{x}\", y \"#{y}\", speed \"#{speed.to_s}\", distance \"#{distance.to_s}\".;#{identity};gesture;"
-		  self
-	    end
+          params.merge!(optional_params)
+          do_gesture(params)
+          do_sleep(speed) 
+
+        rescue Exception => e      
+          $logger.behaviour "FAIL;Failed gesture_from with x \"#{x}\", y \"#{y}\", speed \"#{speed.to_s}\", distance \"#{distance.to_s}\", button \".;#{identity};gesture;"
+          Kernel::raise e        
+        end
+        $logger.behaviour "PASS;Operation gesture_from executed successfully with x \"#{x}\", y \"#{y}\", speed \"#{speed.to_s}\", distance \"#{distance.to_s}\".;#{identity};gesture;"
+        self
+      end
 
-	    # == description
+      # == description
       # Perform a gesture with the object, ending the gesture at the center of another object.
       #
       # == arguments
@@ -430,50 +458,53 @@ module MobyBehaviour
       # == exceptions
       # ArgumentError
       #  description: One of the arguments is not valid  
-	    def gesture_to_object(target_object, duration, optional_params = {:button => :Left, :isDrag => false})    
-            if attribute('objectType') == 'Web'
-              elemens_xml_data, unused_rule = TDriver::TestObjectAdapter.get_objects( @sut.xml_data, { :id => self.attribute('webFrame')}, true )
-              object_xml_data = elemens_xml_data[0]
-              object_attributes = TDriver::TestObjectAdapter.test_object_attributes(object_xml_data, ['x', 'y'])
-              frame_x = object_attributes['x'].to_i
-              frame_y = object_attributes['y'].to_i
-							puts "x "  + frame_x.to_s + " y " + frame_y.to_s
-
-
-              gesture_to(target_object.attribute('x').to_i + (target_object.attribute('width' ).to_i/2) - (attribute('width' ).to_i/2 ) - frame_x,
-                         target_object.attribute('y').to_i + (target_object.attribute('height').to_i/2) - (attribute('height').to_i/2 ) - frame_y,
-                         duration, optional_params)
-              nil
-              return 
-            end
+      def gesture_to_object(target_object, duration, optional_params = {:button => :Left, :isDrag => false})    
+
+      if attribute('objectType') == 'Web'
+        elemens_xml_data, unused_rule = @test_object_adapter.get_objects( @sut.xml_data, { :id => attribute('webFrame')}, true )
+        object_xml_data = elemens_xml_data[0]
+        object_attributes = @test_object_adapter.test_object_attributes(object_xml_data, ['x', 'y'])
+        frame_x = object_attributes['x'].to_i
+        frame_y = object_attributes['y'].to_i
+        puts "x "  + frame_x.to_s + " y " + frame_y.to_s
+
+
+        gesture_to(target_object.attribute('x').to_i + (target_object.attribute('width' ).to_i/2) - (attribute('width' ).to_i/2 ) - frame_x,
+                   target_object.attribute('y').to_i + (target_object.attribute('height').to_i/2) - (attribute('height').to_i/2 ) - frame_y,
+                   duration, optional_params)
+        nil
+        return 
+      end
 
-		  begin
-            # change the format for api consitency
-            use_tap_screen = optional_params[:use_tap_screen].nil? ? $parameters[ @sut.id][ :use_tap_screen, 'false'] :
-              optional_params[:use_tap_screen].to_s
-            optional_params[:useTapScreen] = use_tap_screen
+      begin
 
+        if optional_params[:use_tap_screen].nil?
+          use_tap_screen = sut_parameters[ :use_tap_screen, 'false']
+        else
+          use_tap_screen = optional_params[:use_tap_screen].to_s
+        end
 
+        optional_params[:useTapScreen] = use_tap_screen
 
-            params = {:gesture_type => :MouseGestureTo, :speed => duration}
-            params[:targetId] = target_object.id
-            params[:targetType] = target_object.attribute('objectType')
-            params.merge!(optional_params)
-            do_gesture(params)
-            do_sleep(duration)
+        params = {:gesture_type => :MouseGestureTo, :speed => duration}
+        params[:targetId] = target_object.id
+        params[:targetType] = target_object.attribute('objectType')
+        params.merge!(optional_params)
+        do_gesture(params)
+        do_sleep(duration)
 
-		  rescue Exception => e      
+      rescue Exception => e      
 
-		    $logger.log "behaviour" , "FAIL;Failed gesture_to_object with button.;#{identity};drag;"
-		    Kernel::raise e        
+        $logger.behaviour "FAIL;Failed gesture_to_object with button.;#{identity};drag;"
+        Kernel::raise e        
 
-		  end      
+      end      
 
-		  $logger.log "behaviour" , "PASS;Operation gesture_to_object executed successfully with button.;#{identity};drag;"
+      $logger.behaviour "PASS;Operation gesture_to_object executed successfully with button.;#{identity};drag;"
 
-		  self
+      self
 
-	    end
+      end
 
       # == description
       # Perform a gesture following a track of points.
@@ -509,60 +540,62 @@ module MobyBehaviour
       # == exceptions
       # ArgumentError
       #  description: One of the arguments is not valid
-	    def gesture_points( points, duration, mouse_details = { :press => true, :release => true, :button => :Left, :isDrag => true}, optional_params = {} )
+      def gesture_points( points, duration, mouse_details = { :press => true, :release => true, :button => :Left, :isDrag => true}, optional_params = {} )
 
-		    begin
+        begin
+
+          if optional_params[:use_tap_screen].nil?
+            use_tap_screen = sut_parameters[:use_tap_screen, 'false']
+          else
+            use_tap_screen = optional_params[:use_tap_screen].to_s
+          end
 
-          use_tap_screen = optional_params[:use_tap_screen].nil? ? $parameters[ @sut.id][ :use_tap_screen, 'false'] :
-          optional_params[:use_tap_screen].to_s
           optional_params[:useTapScreen] = use_tap_screen
 
-		      mouse_details[:press] = true  unless mouse_details.has_value?(:press)
-		      mouse_details[:release] = true  unless mouse_details.has_value?(:release)
-		      mouse_details[:button] = :Left  unless mouse_details.has_value?(:button)
-		      mouse_details[:isDrag] = true  unless mouse_details.has_value?(:isDrag)
+          mouse_details[:press] = true  unless mouse_details.has_value?(:press)
+          mouse_details[:release] = true  unless mouse_details.has_value?(:release)
+          mouse_details[:button] = :Left  unless mouse_details.has_value?(:button)
+          mouse_details[:isDrag] = true  unless mouse_details.has_value?(:isDrag)
 
-		      raise ArgumentError.new( "Invalid button." ) unless @@_valid_buttons.include?(mouse_details[:button])
+          raise ArgumentError.new( "Invalid button." ) unless @@_valid_buttons.include?(mouse_details[:button])
 
-		      command = command_params #in qt_behaviour           
-		      command.command_name('MouseGesturePoints')
-		      params = {'mouseMove'=>'true'}
+          command = command_params #in qt_behaviour           
+          command.command_name('MouseGesturePoints')
+          params = {'mouseMove'=>'true'}
 
-		      params['button'] = @@_buttons_map[mouse_details[:button]]
-		      params['press'] = 'false' unless mouse_details[:press]
-		      params['release'] = 'false' unless mouse_details[:release]
-              params['isDrag'] = 'true' if mouse_details[:isDrag]
-              params.merge!(optional_params)
+          params['button'] = @@_buttons_map[mouse_details[:button]]
+          params['press'] = 'false' unless mouse_details[:press]
+          params['release'] = 'false' unless mouse_details[:release]
+          params['isDrag'] = 'true' if mouse_details[:isDrag]
+          params.merge!(optional_params)
               
 
-		      millis = duration.to_f
-		      millis = millis*1000
-		      speed = millis.to_i
-		      params['speed'] = speed.to_s
-		      command.command_params(params)
-		      point_string = ""
-		      points.each { |point| point_string << point["x"].to_s << "," << point["y"].to_s << "," << (point["interval"]*1000).to_i.to_s << ";"}
-		      command.command_value(point_string)
+          millis = duration.to_f
+          millis = millis*1000
+          speed = millis.to_i
+          params['speed'] = speed.to_s
+          command.command_params(params)
+          point_string = ""
+          points.each { |point| point_string << point["x"].to_s << "," << point["y"].to_s << "," << (point["interval"]*1000).to_i.to_s << ";"}
+          command.command_value(point_string)
 
-		      @sut.execute_command(command)
+          @sut.execute_command(command)
 
-		      do_sleep(duration)
+          do_sleep(duration)
 
-		    rescue Exception => e
+        rescue Exception => e
 
-		      $logger.log "behaviour", 
-			    "FAIL;Failed drag_to_object with points \"#{points.to_s}\", duration \"#{duration.to_s}\", mouse_details \"#{mouse_details.to_s}\".;#{identity};gesture_points;"
-		      Kernel::raise e        
+          $logger.behaviour "FAIL;Failed drag_to_object with points \"#{points.to_s}\", duration \"#{duration.to_s}\", mouse_details \"#{mouse_details.to_s}\".;#{identity};gesture_points;"
+          Kernel::raise e        
 
-		    end      
+        end      
 
-		    $logger.log "behaviour", 
-		      "PASS;Operation drag_to_object executed successfully with points \"#{points.to_s}\", duration \"#{duration.to_s}\", mouse_details \"#{mouse_details.to_s}\".;#{identity};gesture_points;"
+        $logger.behaviour "PASS;Operation drag_to_object executed successfully with points \"#{points.to_s}\", duration \"#{duration.to_s}\", mouse_details \"#{mouse_details.to_s}\".;#{identity};gesture_points;"
 
-		    self
-	    end
+        self
+      end
 
-	    # == description
+      # == description
       # Drag the object for the given distance.      
       # By default a drag is a slow gesture.
       #
@@ -601,30 +634,36 @@ module MobyBehaviour
       # == exceptions
       # ArgumentError
       #  description: One of the arguments is not valid  
-	    def drag(direction, distance, button = :Left, optional_params = {})
+      def drag(direction, distance, button = :Left, optional_params = {})
+
+      begin
+
+        if optional_params[:use_tap_screen].nil?
+          use_tap_screen = sut_parameters[:use_tap_screen, 'false']
+        else
+          use_tap_screen = optional_params[:use_tap_screen].to_s
+        end
 
-		  begin
-            use_tap_screen = optional_params[:use_tap_screen].nil? ? $parameters[ @sut.id][ :use_tap_screen, 'false'] :
-              optional_params[:use_tap_screen].to_s
-            optional_params[:useTapScreen] = use_tap_screen
+        optional_params[:useTapScreen] = use_tap_screen
 
-		    speed = calculate_speed( distance, @sut.parameter[ :gesture_drag_speed ] )
-            params = {:gesture_type => :MouseGesture, :direction => direction, :speed => speed, :distance => distance, :isDrag => true, :button => button}
-            params.merge!(optional_params)
-            do_gesture(params)		
-		    do_sleep( speed )
+        speed = calculate_speed( distance, sut_parameters[ :gesture_drag_speed ] )
+        
+        params = {:gesture_type => :MouseGesture, :direction => direction, :speed => speed, :distance => distance, :isDrag => true, :button => button}
+        params.merge!(optional_params)
+        do_gesture(params)    
+        do_sleep( speed )
 
-		  rescue Exception => e      
-		    
-		    $logger.log "behaviour" , "FAIL;Failed drag with direction \"#{direction}\", distance \"#{distance}\", button \"#{button.to_s}\".;#{identity};drag;"
-		    Kernel::raise e        
+      rescue Exception => e      
+        
+        $logger.behaviour "FAIL;Failed drag with direction \"#{direction}\", distance \"#{distance}\", button \"#{button.to_s}\".;#{identity};drag;"
+        Kernel::raise e        
 
-		  end      
+      end      
 
-		  $logger.log "behaviour" , "PASS;Operation drag executed successfully with direction \"#{direction}\", distance \"#{distance}\", button \"#{button.to_s}\".;#{identity};drag;"
+      $logger.behaviour "PASS;Operation drag executed successfully with direction \"#{direction}\", distance \"#{distance}\", button \"#{button.to_s}\".;#{identity};drag;"
 
-		  self
-	    end
+      self
+      end
       
       # == description
       # Drag the object to the given coordinates.
@@ -661,20 +700,20 @@ module MobyBehaviour
       # == exceptions
       # ArgumentError
       #  description: One of the arguments is not valid  
-	    def drag_to( x, y, button = :Left, optional_params= {} )
+      def drag_to( x, y, button = :Left, optional_params= {} )
 
         begin
-          optional_params.merge!({ :isDrag => true , :button=>button})
+          optional_params.merge!({ :isDrag => true, :button=>button})
           distance = distance_to_point(x,y)
-          speed = calculate_speed(distance, @sut.parameter[:gesture_drag_speed])
+          speed = calculate_speed(distance, sut_parameters[:gesture_drag_speed])
           gesture_to(x, y, speed, optional_params )
 
         rescue Exception => e      
-          $logger.log "behaviour" , "FAIL;Failed drag_to with x \"#{x}\", y \"#{y}\", button \"#{button.to_s}\".;#{identity};drag;"
+          $logger.behaviour "FAIL;Failed drag_to with x \"#{x}\", y \"#{y}\", button \"#{button.to_s}\".;#{identity};drag;"
           Kernel::raise e        
         end      
 
-        $logger.log "behaviour" , "PASS;Operation drag_to executed successfully with x \"#{x}\", y \"#{y}\", button \"#{button.to_s}\".;#{identity};drag;"
+        $logger.behaviour "PASS;Operation drag_to executed successfully with x \"#{x}\", y \"#{y}\", button \"#{button.to_s}\".;#{identity};drag;"
 
         self
 
@@ -710,40 +749,44 @@ module MobyBehaviour
       # == exceptions
       # ArgumentError
       #   description: One of the arguments is not valid   
-	    def drag_to_object(target_object, button = :Left, optional_params = {})       
+      def drag_to_object(target_object, button = :Left, optional_params = {})       
+
+        begin
 
-		    begin
+          if optional_params[:use_tap_screen].nil? 
+            use_tap_screen = sut_parameters[:use_tap_screen, 'false']
+          else
+            use_tap_screen = optional_params[:use_tap_screen].to_s
+          end
 
-          use_tap_screen = optional_params[:use_tap_screen].nil? ? $parameters[ @sut.id][ :use_tap_screen, 'false'] :
-          optional_params[:use_tap_screen].to_s
           optional_params[:useTapScreen] = use_tap_screen
 
-		      distance = distance_to_point(target_object.object_center_x, target_object.object_center_y)
-		      #no drag needed, maybe even attempting to drag to it self
-		      return if distance == 0
+          distance = distance_to_point(target_object.object_center_x, target_object.object_center_y)
+          #no drag needed, maybe even attempting to drag to it self
+          return if distance == 0
 
-		      speed = calculate_speed(distance, @sut.parameter[:gesture_drag_speed])
+          speed = calculate_speed(distance, sut_parameters[:gesture_drag_speed])
           params = {:gesture_type => :MouseGestureTo, :speed => speed, :isDrag => true, :button => button}
           params[:targetId] = target_object.id
           params[:targetType] = target_object.attribute('objectType')
           params.merge!(optional_params)
           do_gesture(params)
-		      do_sleep(speed)
+          do_sleep(speed)
 
-		    rescue Exception => e      
+        rescue Exception => e      
 
-		      $logger.log "behaviour" , "FAIL;Failed drag_to_object with button \"#{button.to_s}\".;#{identity};drag;"
-		      Kernel::raise e        
+          $logger.behaviour "FAIL;Failed drag_to_object with button \"#{button.to_s}\".;#{identity};drag;"
+          Kernel::raise e        
 
-		    end      
+        end      
 
-		    $logger.log "behaviour" , "PASS;Operation drag_to_object executed successfully with button \"#{button.to_s}\".;#{identity};drag;"
+        $logger.behaviour "PASS;Operation drag_to_object executed successfully with button \"#{button.to_s}\".;#{identity};drag;"
 
-		    self
+        self
 
-	    end
+      end
       
-	    # == description
+      # == description
       # Perform a pointer move starting at the object
       #
       # == arguments
@@ -781,154 +824,160 @@ module MobyBehaviour
       # == exceptions
       # ArgumentError
       #  description: One of the arguments is not valid    
-	    def move(direction, distance, button = :Left, optional_params = {})
+      def move(direction, distance, button = :Left, optional_params = {})
+
+        begin
 
-		    begin
+          if optional_params[:use_tap_screen].nil?
+            use_tap_screen = sut_parameters[:use_tap_screen, 'false']
+          else
+            use_tap_screen = optional_params[:use_tap_screen].to_s
+          end
 
-          use_tap_screen = optional_params[:use_tap_screen].nil? ? $parameters[ @sut.id][ :use_tap_screen, 'false'] :
           optional_params[:use_tap_screen].to_s
           optional_params[:useTapScreen] = use_tap_screen
 
-		      speed = calculate_speed( distance, @sut.parameter[ :gesture_drag_speed ] )
+          speed = calculate_speed( distance, sut_parameters[ :gesture_drag_speed ] )
           params = {:gesture_type => :MouseGesture, :direction => direction, :speed => speed, :distance => distance, :isDrag => false, :button => button, :isMove => true}
           params.merge!(optional_params)
           do_gesture(params)
-		      do_sleep( speed )
+          do_sleep( speed )
 
-		    rescue Exception => e      
+        rescue Exception => e      
 
-		      $logger.log "behaviour" , "FAIL;Failed move with direction \"#{direction}\", distance \"#{distance}\",.;#{identity};move;"
-		      Kernel::raise e        
+          $logger.behaviour "FAIL;Failed move with direction \"#{direction}\", distance \"#{distance}\",.;#{identity};move;"
+          Kernel::raise e        
 
-		    end      
+        end      
 
-		    $logger.log "behaviour" , "PASS;Operation move executed successfully with direction \"#{direction}\", distance \"#{distance}\",.;#{identity};move;"
+        $logger.behaviour "PASS;Operation move executed successfully with direction \"#{direction}\", distance \"#{distance}\",.;#{identity};move;"
 
-		    self
+        self
 
-	    end
+      end
        
 
       # == nodoc
-	    # utility function for getting the x coordinate of the center of the object, should this be private method?
-	    def object_center_x
-  		  center_x
-	    end
+      # utility function for getting the x coordinate of the center of the object, should this be private method?
+      def object_center_x
+        center_x
+      end
 
       # == nodoc
-	    # utility function for getting the y coordinate of the center of the object, should this be private method?
-	    def object_center_y
-  		  center_y
-	    end  
+      # utility function for getting the y coordinate of the center of the object, should this be private method?
+      def object_center_y
+        center_y
+      end  
 
     private
 
-	    # Performs the actual gesture operation. 
-	    # Verifies that the parameters are correct and send the command
-	    # to the sut. 
-	    # gesture_type: :MouseGesture, :MouseGestureTo, :MouseGestureToCoordinates
-	    # params = {:direction => :Up, duration => 2, :distance =>100, :isDrag =>false, :isMove =>false }
-	    def do_gesture(params)
-		    validate_gesture_params!(params)
-
-		    if attribute('objectType') == 'Embedded' or attribute('objectType') == 'Web'
-		      params['obj_x'] = center_x
-		      params['obj_y'] = center_y
-		      params['useCoordinates'] = 'true'
-		    end
+      # Performs the actual gesture operation. 
+      # Verifies that the parameters are correct and send the command
+      # to the sut. 
+      # gesture_type: :MouseGesture, :MouseGestureTo, :MouseGestureToCoordinates
+      # params = {:direction => :Up, duration => 2, :distance =>100, :isDrag =>false, :isMove =>false }
+      def do_gesture(params)
 
-		    command = command_params #in qt_behaviour           
-		    command.command_name(params[:gesture_type].to_s)
-		    command.command_params( params )
-		    @sut.execute_command( command )
-	    end
+        validate_gesture_params!(params)
 
-	    def validate_gesture_params!(params)
-		    #direction		
-		    if params[:gesture_type] == :MouseGesture or params[:gesture_type] == :MouseGestureFromCoordinates
-		      if params[:direction].kind_of?(Integer)
-			    raise ArgumentError.new( "Invalid direction." ) unless 0 <= params[:direction].to_i and params[:direction].to_i <= 360 
-		      else
-			    raise ArgumentError.new( "Invalid direction." ) unless @@_valid_directions.include?(params[:direction])  
-			    params[:direction] = @@_direction_map[params[:direction]]
-		      end
-		      #distance
-		      params[:distance] = params[:distance].to_i unless params[:distance].kind_of?(Integer)
-		      raise ArgumentError.new( "Distance must be an integer and greater than zero." ) unless  params[:distance] > 0
-		    elsif params[:gesture_type] == :MouseGestureToCoordinates or params[:gesture_type] == :MouseGestureFromCoordinates
-		      raise ArgumentError.new("X and Y must be integers.") unless params[:x].kind_of?(Integer) and params[:y].kind_of?(Integer)
-		    elsif params[:gesture_type] == :MouseGestureTo
-		      raise ArgumentError.new("targetId and targetType must be defined.") unless params[:targetId] and params[:targetType]
-		    end			  
-
-		    #duration/speed 
-		    params[:speed] = params[:speed].to_f unless params[:speed].kind_of?(Numeric)
-		    raise ArgumentError.new( "Duration must be a number and greated than zero, was:" + params[:speed].to_s) unless params[:speed] > 0
-		    duration_secs = params[:speed].to_f
-		    duration_secs = duration_secs*1000
-		    params[:speed] = duration_secs.to_i
-
-		    #mouseMove true always
-		    params[:mouseMove] = true
+        if attribute('objectType') == 'Embedded' or attribute('objectType') == 'Web'
+          params['obj_x'] = center_x
+          params['obj_y'] = center_y
+          params['useCoordinates'] = 'true'
+        end
 
-		    params[:button] = :Left unless params[:button]
-		    raise ArgumentError.new( "Invalid button." ) unless @@_valid_buttons.include?(params[:button])
-		    params[:button] = @@_buttons_map[params[:button]]
+        command = command_params #in qt_behaviour           
+        command.command_name(params[:gesture_type].to_s)
+        command.command_params( params )
+        @sut.execute_command( command )
+      end
 
-		    if params[:isMove] == true
-		      params[:press] = 'false'
-		      params[:release] = 'false'
-		    end
+      def validate_gesture_params!(params)
+        #direction    
+        if params[:gesture_type] == :MouseGesture or params[:gesture_type] == :MouseGestureFromCoordinates
+          if params[:direction].kind_of?(Integer)
+          raise ArgumentError.new( "Invalid direction." ) unless 0 <= params[:direction].to_i and params[:direction].to_i <= 360 
+          else
+          raise ArgumentError.new( "Invalid direction." ) unless @@_valid_directions.include?(params[:direction])  
+          params[:direction] = @@_direction_map[params[:direction]]
+          end
+          #distance
+          params[:distance] = params[:distance].to_i unless params[:distance].kind_of?(Integer)
+          raise ArgumentError.new( "Distance must be an integer and greater than zero." ) unless  params[:distance] > 0
+        elsif params[:gesture_type] == :MouseGestureToCoordinates or params[:gesture_type] == :MouseGestureFromCoordinates
+          raise ArgumentError.new("X and Y must be integers.") unless params[:x].kind_of?(Integer) and params[:y].kind_of?(Integer)
+        elsif params[:gesture_type] == :MouseGestureTo
+          raise ArgumentError.new("targetId and targetType must be defined.") unless params[:targetId] and params[:targetType]
+        end        
+
+        #duration/speed 
+        params[:speed] = params[:speed].to_f unless params[:speed].kind_of?(Numeric)
+        raise ArgumentError.new( "Duration must be a number and greated than zero, was:" + params[:speed].to_s) unless params[:speed] > 0
+        duration_secs = params[:speed].to_f
+        duration_secs = duration_secs*1000
+        params[:speed] = duration_secs.to_i
+
+        #mouseMove true always
+        params[:mouseMove] = true
+
+        params[:button] = :Left unless params[:button]
+        raise ArgumentError.new( "Invalid button." ) unless @@_valid_buttons.include?(params[:button])
+        params[:button] = @@_buttons_map[params[:button]]
+
+        if params[:isMove] == true
+          params[:press] = 'false'
+          params[:release] = 'false'
+        end
 
-	    end
+      end
 
-	    def do_sleep(time)
+      def do_sleep(time)
 
-		    if $parameters[ @sut.id ][ :sleep_disabled, nil ] != true
+        if sut_parameters[ :sleep_disabled, nil ] != true
 
-		      time = time.to_f * 1.3
+          time = time.to_f * 1.3
 
-		      #for flicks the duration of the gesture is short but animation (scroll etc..) may not
-		      #so wait at least one second
-		      time = 1 if time < 1
+          #for flicks the duration of the gesture is short but animation (scroll etc..) may not
+          #so wait at least one second
+          time = 1 if time < 1
 
-		      sleep time
+          sleep time
 
-		    else
+        else
 
-		      # store the biggest value which will then be used in multitouch situations to sleep
-		      $parameters[ @sut.id ][ :skipped_sleep_time ] = time if time > $parameters[ @sut.id ][ :skipped_sleep_time, 0 ]
+          # store the biggest value which will then be used in multitouch situations to sleep
+          sut_parameters[ :skipped_sleep_time ] = time if time > sut_parameters[ :skipped_sleep_time, 0 ]
 
-		    end
+        end
 
-	    end
+      end
 
-	    def calculate_speed(distance, speed)
+      def calculate_speed(distance, speed)
 
-		    distance = distance.to_f
-		    speed = speed.to_f
-		    duration = distance/speed
-		    duration
+        distance = distance.to_f
+        speed = speed.to_f
+        duration = distance/speed
+        duration
 
-	    end
+      end
 
-	    def distance_to_point(x, y)
+      def distance_to_point(x, y)
 
-		    x = x.to_i
-		    y = y.to_i
-		    dist_x = x - center_x.to_i
-		    dist_y = y - center_y.to_i
+        x = x.to_i
+        y = y.to_i
+        dist_x = x - center_x.to_i
+        dist_y = y - center_y.to_i
 
-		    return 0 if dist_y == 0 and dist_x == 0     
-		    distance = Math.hypot( dist_x, dist_y )
-		    distance
+        return 0 if dist_y == 0 and dist_x == 0     
+        distance = Math.hypot( dist_x, dist_y )
+        distance
 
-	    end
+      end
 
-	    # enable hooking for performance measurement & debug logging
-	    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+      # enable hooking for performance measurement & debug logging
+      TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
-	  end
+    end
 
   end
 end