testability-driver-qt-sut-plugin 0.9.2

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

@@ -0,0 +1,152 @@
+############################################################################
+## 
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+## All rights reserved. 
+## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
+## 
+## This file is part of TDriver. 
+## 
+## If you have questions regarding the use of this file, please contact 
+## Nokia at testabilitydriver@nokia.com . 
+## 
+## This library is free software; you can redistribute it and/or 
+## modify it under the terms of the GNU Lesser General Public 
+## License version 2.1 as published by the Free Software Foundation 
+## and appearing in the file LICENSE.LGPL included in the packaging 
+## of this file. 
+## 
+############################################################################
+ 
+module MobyBehaviour
+
+	module QT
+
+    # == description
+    # KeyPress specific behaviours
+    #
+    # == behaviour
+    # QtKeyPress
+    #
+    # == requires
+    # testability-driver-qt-sut-plugin
+    #
+    # == input_type
+    # *
+    #
+    # == sut_type
+    # qt
+    #
+    # == sut_version
+    # *
+    #
+    # == objects
+    # *
+    #
+		module KeyPress
+
+			include MobyBehaviour::QT::Behaviour
+
+			# == description
+			# Perform key press event or a series of events on an object.
+			# 
+			# == arguments
+			# key
+			#  Symbol
+			#   description: Symbol of key
+			#   example: :kRight
+			#  Integer
+			#   description: Scan code of key
+			#   example: 	0x01000001
+			#  MobyCommand::KeySequence
+			#   description: Sequence of key and press types, see [link="#GenericSut:press_key"]KeySequence reference[/link].
+			#   example: MobyCommand::KeySequence.new( :kTab, :KeyDown )
+			#
+			# == returns
+			# NilClass
+			#  description: nil
+			#  example: nil
+			#
+			# == exceptions
+			# ArgumentError
+			#  description: Wrong argument type %s for key (Expected: %s)
+			# ArgumentError
+			#  description: Scan code for :%s not defined in keymap
+			# ArgumentError
+			#  description: Error occured during keypress (Response: %s)
+			def press_key( key )
+
+				begin
+
+					command = command_params
+					command.command_name('KeyPress')
+					command.set_require_response( true )
+
+					# raise exception if value type other than Fixnum or Symbol
+					Kernel::raise ArgumentError.new( "Wrong argument type %s for key (Expected: %s)" % [ key.class, "Symbol/Fixnum/KeySequence" ] ) unless [ Fixnum, Symbol, MobyCommand::KeySequence ].include?( key.class )  
+
+					# verify that keymap is defined for sut if symbol used. 
+					Kernel::raise ArgumentError.new(
+
+					  "Symbol #{ key.inspect } cannot be used due to no keymap defined for #{ @sut.id } in TDriver configuration file."
+
+					) if key.kind_of?( Symbol ) && !MobyUtil::Parameter[ @sut.id ].has_key?( :keymap )
+
+					@key_sequence = nil
+					if key.kind_of?( Symbol )
+
+					  scancode = MobyUtil::Parameter[ @sut.id ][ :keymap ][ key, nil ]
+					  scancode = scancode.hex if scancode.kind_of?( String )
+					  # raise exception if value is other than fixnum
+					  Kernel::raise ArgumentError.new( "Scan code for :%s not defined in keymap" % key ) unless scancode.kind_of?( Fixnum )
+
+					  # add scancode for keypress event
+					  command.command_value( scancode.to_s )
+
+					elsif key.kind_of?( MobyCommand::KeySequence )
+					
+					  @key_sequence = []
+					  key.get_sequence.each do | key_event |
+					      
+					  tempcode = MobyUtil::Parameter[ @sut.id ][ :keymap ][ key_event[ :value ], nil ]
+					  tempcode = tempcode.hex if tempcode.kind_of?( String )
+						
+					  press_type = { :KeyDown => 'KeyPress', :KeyUp => 'KeyRelease' }.fetch( key_event[ :type ] ){ "KeyClick" }
+					  @key_sequence << { :value => tempcode, :params => { :name => press_type, :modifiers => "0", :delay => "0" } }
+												
+					  end					  
+					  command.command_value( @key_sequence )
+					else
+
+				      scancode = key.to_i
+					
+					  # raise exception if value is other than fixnum
+					  Kernel::raise ArgumentError.new( "Scan code for :%s not defined in keymap" % key ) unless scancode.kind_of?( Fixnum )
+
+					  # add scancode for keypress event
+					  command.command_value( scancode.to_s )
+					end	
+
+					# execute command & verify that execution passed ("OK" expected as response) 
+					@sut.execute_command(command)
+					#Kernel::raise RuntimeError.new("Error occured during keypress (Response: %s)" % @response ) unless ( @response = @sut.execute_command(command) ) == "OK" 
+
+				rescue Exception => exception
+
+					MobyUtil::Logger.instance.log "behaviour" , "FAIL;Failed press_key with key \"#{ key }\".;#{ identity };press_key;"
+					Kernel::raise exception
+
+				end
+
+				MobyUtil::Logger.instance.log "behaviour" , "PASS;Operation press_key executed successfully with key \"#{ key }\".;#{ identity };press_key;"
+		
+				nil
+			
+			end
+
+			# enable hooking for performance measurement & debug logging
+			MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+
+		end
+
+	end
+end

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

@@ -0,0 +1,151 @@
+############################################################################
+## 
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+## All rights reserved. 
+## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
+## 
+## This file is part of TDriver. 
+## 
+## If you have questions regarding the use of this file, please contact 
+## Nokia at testabilitydriver@nokia.com . 
+## 
+## This library is free software; you can redistribute it and/or 
+## modify it under the terms of the GNU Lesser General Public 
+## License version 2.1 as published by the Free Software Foundation 
+## and appearing in the file LICENSE.LGPL included in the packaging 
+## of this file. 
+## 
+############################################################################
+
+require 'tmpdir'
+require 'base64'
+
+module MobyBehaviour
+
+  module QT
+
+    # == description
+    # LocalisationDB specific behaviours
+    #
+    # == behaviour
+    # QtLocalisationDB
+    #
+    # == requires
+    # testability-driver-qt-sut-plugin
+    #
+    # == input_type
+    # *
+    #
+    # == sut_type
+    # qt
+    #
+    # == sut_version
+    # *
+    #
+    # == objects
+    # sut
+    #
+    module LocalisationDB
+
+      include MobyBehaviour::QT::Behaviour
+
+      # == description
+      # Creates a new localisation able for translation using the tdriver_parameters to locate the Localization DB. 
+      # It uses the temporary folder to store temporary translation files.
+      #
+      # == arguments
+      # path
+      #  String
+      #   description: Path where the translation files to upload to the database are found
+      #   example: "/usr/me/tdriver/localization_files"
+      #
+      # file
+      #  String
+      #   description: File names of the translation files to be uploaded.
+      #	  example: "*.ts"
+      #
+      # database_file
+      #  String
+      #   description: If this is provided it will overwrite the value set in the parameter ':localisation_server_database_name'
+      #   example: "mysqlitedb.sqlite"
+      #
+      # column_names_map
+      #  Hash
+      #   description: Hash with the language codes from the translation files as keys and the desired column names as values
+      #   example: {"en" => "en_GB"}
+      #
+      # == returns
+      # NilClass
+      #   description: -
+      #   example: -
+      #
+      def create_locale_db(path = "/", file = "*.qm", database_file = nil, column_names_map = {} )
+
+		    db_type =  MobyUtil::Parameter[ :localisation_db_type ]
+		    host =  MobyUtil::Parameter[ :localisation_server_ip ]
+		    database_file = MobyUtil::Parameter[ :localisation_server_database_name ] if database_file.nil?
+		    username = MobyUtil::Parameter[ :localisation_server_username ]
+		    password = MobyUtil::Parameter[ :localisation_server_password ]
+		
+		    db_connection = MobyUtil::DBConnection.new(  db_type, host, database_file, username, password )
+		    table_name = MobyUtil::Parameter[ :sut_qt ][ :localisation_server_database_tablename, "" ]
+                    
+		    begin
+			    tmp_path = MobyUtil::Parameter[:tmp_folder] + "/locale_db_tmp"
+		    rescue MobyUtil::ParameterNotFoundError
+			    tmp_path = Dir.tmpdir + "/locale_db_tmp"
+		    end
+		
+        if (File.directory? tmp_path)
+        FileUtils.rm_rf(tmp_path)
+        end
+
+        if (File.directory? tmp_path)
+        else
+        FileUtils.mkdir(tmp_path)
+        end
+
+        list_of_files = receive_files( path, file, tmp_path )
+
+        list_of_files.each do |e_file|
+          begin
+            MobyUtil::Localisation.upload_translation_file( e_file, table_name, db_connection, column_names_map)	
+          rescue Exception => e
+            puts "Error while uploading #{e_file}."
+            puts e.message
+          end
+        end
+
+        nil
+
+      end
+	  
+	  private 
+	  
+	    # == description
+      # Receives files from SUT
+	    #
+      def receive_files( device_path, file, tmp_path )
+
+        list_of_files = fixture( "file", "list_files", {:file_name => file, :file_path => device_path} ).split(';')
+        new_list_of_files = Array.new
+
+        list_of_files.each do |name|
+          new_list_of_files.push( tmp_path + "/" + File.basename(name) )
+          file = File.open(tmp_path + "/" + File.basename(name), 'w')
+          file << Base64.decode64( fixture("file", "read_file", {:file_name => name}) )
+          file.close
+        end
+
+        return new_list_of_files
+
+      end
+
+	    # enable hooking for performance measurement & debug logging
+	    MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+
+    end # LocalisationDB
+
+  end # QT
+
+end # MobyBehaviour

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

@@ -0,0 +1,85 @@
+############################################################################
+## 
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+## All rights reserved. 
+## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
+## 
+## This file is part of TDriver. 
+## 
+## If you have questions regarding the use of this file, please contact 
+## Nokia at testabilitydriver@nokia.com . 
+## 
+## This library is free software; you can redistribute it and/or 
+## modify it under the terms of the GNU Lesser General Public 
+## License version 2.1 as published by the Free Software Foundation 
+## and appearing in the file LICENSE.LGPL included in the packaging 
+## of this file. 
+## 
+############################################################################
+
+module MobyBehaviour
+
+	module QT
+
+    # == description
+    # Method specific behaviours
+    #
+    # == behaviour
+    # QtMethod
+    #
+    # == requires
+    # testability-driver-qt-sut-plugin
+    #
+    # == input_type
+    # *
+    #
+    # == sut_type
+    # qt
+    #
+    # == sut_version
+    # *
+    #
+    # == objects
+    # *
+    #
+		module Method
+
+			include MobyBehaviour::QT::Behaviour
+
+			# == description
+			# Calls an invokable method of the Qt test object.
+			# Slots and signals are automatically invokable, but other methods must be explicitly made invokable.
+			# This version does not support method arguments or return values.
+			# 
+			# == arguments
+			# method_name
+			#  String
+			#   description: name of method to invoke, including empty parenthesis
+			#   example: "clear()"
+			#
+			# == returns
+			# Undefined
+			#  description: on success, returns unspecified value of unspecified type
+			#  example: "OK"
+			#
+			# == exceptions
+			# RuntimeError
+			#   description: invoking the method failed
+			def call_method( method_name )
+
+				Kernel::raise ArgumentError.new( "Method name was empty" ) if method_name.empty?
+				command = command_params #in qt_behaviour      
+				command.transitions_off     
+				command.command_name( 'CallMethod' )
+				command.command_params( 'method_name' => method_name.to_s )
+				command.service( 'objectManipulation' )
+				returnValue = @sut.execute_command( command )
+				Kernel::raise RuntimeError.new( "Calling method '%s' failed with error: %s" % [ method_name, returnValue ] ) if ( returnValue != "OK" )
+			end
+
+			# enable hooking for performance measurement & debug logging
+			MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+
+		end
+	end
+end

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

@@ -0,0 +1,455 @@
+############################################################################
+## 
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+## All rights reserved. 
+## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
+## 
+## This file is part of TDriver. 
+## 
+## If you have questions regarding the use of this file, please contact 
+## Nokia at testabilitydriver@nokia.com . 
+## 
+## This library is free software; you can redistribute it and/or 
+## modify it under the terms of the GNU Lesser General Public 
+## License version 2.1 as published by the Free Software Foundation 
+## and appearing in the file LICENSE.LGPL included in the packaging 
+## of this file. 
+## 
+############################################################################
+
+module MobyBehaviour
+
+  module QT
+
+    # == description
+    # Behaviours for multitouch operations. 
+    #
+    # == behaviour
+    # QtMultitouch
+    #
+    # == requires
+    # testability-driver-qt-sut-plugin
+    #
+    # == input_type
+    # touch
+    #
+    # == sut_type
+    # qt
+    #
+    # == sut_version
+    # *
+    #
+    # == objects
+    # *
+    #
+	  module Multitouch
+
+	    include MobyBehaviour::QT::Behaviour
+
+      # == description
+      # Performs a pinch zoom in operation. The distance of the operation is 
+      # is for both fingers. So a distance of 100 will be performed by both
+      # end points (fingers).
+      #
+      # == arguments
+      # speed
+      #  Integer
+      #   description: Speed of the operation in seconds
+      #   example: 3
+      #
+      # distance
+      #  Integer
+      #   description: Distance of the pinch zoom
+      #   example: 100
+      #
+      # direction
+      #  Integer
+      #   description: Direction of the pinch zoom in degrees 0-180
+      #   example: 90
+      #  Symbol
+      #   description: Direction of the pinch zoom either :Horizontal or :Vertical
+      #   example: :Horizontal
+      #
+      # differential
+      #  Integer
+      #   description: The difference from where the zoom starts or ends (how far apart are the fingers when starting the zoom)
+      #   example: 10
+      #
+      # == returns
+      # NilClass
+      #   description: -
+      #   example: -
+      #
+      # == exceptions
+      # ArgumentError
+      #  description:  In case the given parameters are not valid.
+      #    
+      # == info
+      # See method pinch_zoom
+      #
+	    def pinch_zoom_in(speed, distance, direction, differential = 10)
+  		  pinch_zoom({:type => :in, :speed => speed, :distance_1 => distance, :distance_2 => distance, :direction => direction, :differential => differential})
+	    end
+
+      # == description
+      # Performs a pinch zoom out operation. The distance of the operation is 
+      # is for both fingers. So a distance of 100 will be performed by both
+      # fingers.
+      #
+      # == arguments
+      # speed
+      #  Integer
+      #   description: Speed of the operation in seconds
+      #   example: 3
+      #
+      # distance
+      #  Integer
+      #   description: Distance of the pinch zoom
+      #   example: 100
+      #
+      # direction
+      #  Integer
+      #   description: Direction of the pinch zoom in degrees 0-180
+      #   example: 90
+      #  Symbol
+      #   description: Direction of the pinch zoom either :Horizontal or :Vertical
+      #   example: :Horizontal
+      #
+      # differential
+      #  Integer
+      #   description: The difference from where the zoom starts or ends (how far apart are the fingers when starting the zoom)
+      #   example: 10
+      #
+      # == returns
+      # NilClass
+      #   description: -
+      #   example: -
+      #
+      # == exceptions
+      # ArgumentError
+      #  description:  In case the given parameters are not valid.
+      #    
+      # == info
+      # See method pinch_zoom
+      #
+	    def pinch_zoom_out(speed, distance, direction, differential = 10)
+  		  pinch_zoom({:type => :out, :speed => speed, :distance_1 => distance, :distance_2 => distance, :direction => direction, :differential => differential})
+	    end
+
+      # == description
+      # Causes a pinch zoom gesture on the object. The type of the pinch is based on the given parameters. 
+      # The parameters make it possible to define various kinds of pinch zoom operations.
+      #
+      # The image shows how the different parameters will be used to make the pinch gesture. 
+      # The image show a zoom in type gesture (:type => :in). Direction is the angle of the 
+      # first part of the pinch gesture against the y axel (0 degrees is up). Distance variables 
+      # do not have to be the same. This means that you can set the gesture so that one finger 
+      # moves a longer distance than the other (or even set one distance to 0). 
+      # The :differential parameter determines the how close the nearest points 
+      # in the pinch gesture are (:in start points and :out end points). 
+      # The center points can be set using the :x and :y setting. 
+      # The values are relative to the object and if not set then the center point of the object is used.
+      # \n
+      # [img="images/pinch.png"]Pinch zoom parameters[/img]
+      #
+      # == arguments
+      # params
+      #  Hash 
+      #   description:
+      #    A Hash table contains all of the parameters required to make the pinch zoom. 
+      #    See [link="#pinch_options_table"]Pinch options table[/link] for valid keys. 
+      #    example: pinch_zoom({:type => :in, :speed => 2, :distance_1 => 100, :distance_2 => 100, :direction => :Vertical, :differential => 10})
+      #
+      # == tables
+      # pinch_options_table
+      #  title: Pinch options table
+      #  |Key|Type|Description|Accepted values|Example|Required|
+      #  |:type|Symbol|Zoom in or out|:in,:out|:type => :in|Yes|
+      #  |:speed|Integer|Speed of the gesture in seconds|Positive Integer|:speed => 2|Yes|
+      #  |:distance_1|Integer|Distance of the first finger zoom gesture|Positive integer|:distance_1 => 100|Yes|
+      #  |:distance_2|Integer|Distance of the second finger zoom gesture|Positive integer|:distance_2 => 100|Yes|
+      #  |:differential|Integer|The difference from where the zoom starts or ends|Positive integer|:differential => 10|Yes|
+      #  |:x|Integer|X coordinate of the center point for the pinch (relative to the object). Optional defaults to center point but if set y must also be set.|Positive Integer| :x => 120|No|
+      #  |:y|Integer|Y coordinate of the center point for the pinch (relative to the object). Optional defaults to center point but if set x must also be set.|Positive Integer|:y => 200|No|
+      #
+      # == returns
+      # NilClass
+      #   description: -
+      #   example: -
+      #
+      # == exceptions
+      # ArgumentError
+      #  description:  In case the given parameters are not valid.
+      #    
+	    def pinch_zoom(params)
+
+		    begin
+		      verify_pinch_params!(params)
+
+		      #convert speed to millis
+		      time = params[:speed].to_f
+		      speed = time*1000
+		      params[:speed] = speed.to_i
+		      if params[:x].kind_of?(Integer) and params[:y].kind_of?(Integer)
+			    params[:useCoordinates] = 'true' 
+			    params[:x] = attribute('x_absolute').to_i + params[:x]
+			    params[:y] = attribute('y_absolute').to_i + params[:y]
+		      end
+		      command = command_params #in qt_behaviour           
+		      command.command_name('PinchZoom')
+		      command.command_params(params)
+
+		      @sut.execute_command( command )
+
+		      #wait untill the pinch is finished
+		      do_sleep(time)
+
+		    rescue Exception => e      
+		      MobyUtil::Logger.instance.log "behaviour","FAIL;Failed pinch_zoom with params \"#{params.to_s}\".;#{identity};pinch_zoom;"
+		      Kernel::raise e        
+		    end      
+		    MobyUtil::Logger.instance.log "behaviour","PASS;Operation pinch_zoom succeeded with params \"#{params.to_s}\".;#{identity};pinch_zoom;"
+		    nil	
+	    end
+
+      # == description
+      # Causes rotation motion on the object. The rotation will be so that one point is stationary 
+      # while other moves to create a rotation motion (like a hinge).
+      #
+      # == arguments
+      # radius
+      #  Integer
+      #   description: Radius of the of the rotation in degrees (distance between the points)
+      #   example: 100
+      #
+      # start_angle
+      #  Integer
+      #   description: Starting angle of the rotation. Integer from 0-360
+      #   example: 90
+      #  Symbol
+      #   description: Starting angle of the rotation. Symbol :Horizontal or :Vertical
+      #   example: :Horizontal
+      #
+      # rotate_direction
+      #  Symbol
+      #   description: Rotation direction :Clockwise or :CounterClockwise. 
+      #   example: :CounterClockwise
+      #
+      # distance
+      #  Integer
+      #   description: Distance of the rotation in degrees
+      #   example: 360
+      #
+      # speed
+      #  Integer
+      #   description: Speed in seconds
+      #   example: 3
+      #
+      # center_point
+      #  Hash
+      #   description: Optional X and Y coordinates (relative to the object e.g. top left of the object is 0.0). 
+      #                In one point rotation the other end point will remain stationary (the rotation is done around that point)
+      #                and that will be the given point. If not given the point will be the center of the object.
+      #   example: {:x => 50, :y => 100}
+      #
+      # == returns
+      # NilClass
+      #   description: -
+      #   example: -
+      #
+      #
+      # == exceptions
+      # ArgumentError
+      #  description:  In case the given parameters are not valid.
+      #    
+      # == info
+      # See method rotate
+      #
+	    def one_point_rotate(radius, start_angle, rotate_direction, distance, speed, center_point = nil)
+		    params = {:type => :one_point, :radius => radius, :rotate_direction => rotate_direction, :distance => distance, :speed => speed, :direction => start_angle}
+		    params.merge!(center_point) if center_point 
+		    rotate(params)
+	    end
+	    
+      # == description
+      # Causes ratation motion on the object. The rotation will be so that both ends move to create a rotation motion around a point.
+      #
+      # == arguments
+      # radius
+      #  Integer
+      #   description: Radius of the of the rotation in degrees (distance between the points)
+      #   example: 100
+      #
+      # start_angle
+      #  Integer
+      #   description: Starting angle of the rotation. Integer from 0-360
+      #   example: 90
+      #  Symbol
+      #   description: Starting angle of the rotation. Symbol :Horizontal or :Vertical
+      #   example: :Horizontal
+      #
+      # rotate_direction
+      #  Symbol
+      #   description: Rotation direction :Clockwise or :CounterClockwise. 
+      #   example: :CounterClockwise
+      #
+      # distance
+      #  Integer
+      #   description: Distance of the rotation in degrees
+      #   example: 360
+      #
+      # speed
+      #  Integer
+      #   description: Speed in seconds
+      #   example: 3
+      #
+      # center_point
+      #  Hash
+      #   description: Optional X and Y coordinates (relative to the object e.g. top left of the object is 0.0). 
+      #                In two point rotation both end points will rotate around a center point which will be
+      #                the given point. If not given the point will be the center of the object.
+      #   example: {:x => 50, :y => 100}
+      #
+      # == returns
+      # NilClass
+      #   description: -
+      #   example: -
+      #
+      # == exceptions
+      #
+      # ArgumentError
+      #  description:  In case the given parameters are not valid.
+      #    
+      # == info
+      # See method rotate
+      #
+	    def two_point_rotate(radius, start_angle, rotate_direction, distance, speed, center_point = nil)
+		    params = {:type => :two_point, :radius => radius, :rotate_direction => rotate_direction, :distance => distance, :speed => speed, :direction => start_angle}
+		    params.merge!(center_point) if center_point 
+		    rotate(params)
+	    end
+
+      # == description
+      # Causes a rotate motion on the screen using two fingers (e.g. like turning a knob). Similar gesture to pinch zooming except the angle changes.
+      # \n
+      # \n
+      # [img="images/rotate.png"]Rotation parameters[/img]
+      # \n
+      # The image shows how the different parameters will be used to make the rotation gestures in both 
+      # one point and two point rotations. In one point rotation the other end remains stationary while 
+      # the other moves around it based on the given radius. In two point rotation the movement is done 
+      # by both ends. Note the direction paramters as the :direction parameter defines the starting angle 
+      # for the gesture and :rotation_direction defines the actual rotation direction (clockwise or counter clockwise). 
+      # When performing two point rotation note that the radius is in fact a radius not the diameter. 
+      # Distance is given in degrees from 0-360. Center point can be set using :x and :y and if 
+      # not set the center point of the object will be used.
+      #
+      # == arguments
+      # params
+      #  Hash
+      #   description: A hash of the parameters that define the rotation. See [link="#rotate_options_table"]Rotate options table[/link] for valid keys
+      #
+      #   example: {:type => :one_point, :radius => 100, :rotate_direction => :Clockwise, :distance => 45, :speed => 2, :direction => 35, :x => 2, y => 35}
+      #
+      # == tables
+      # rotate_options_table
+      #  title: Rotate options table
+      #  |Key|Type|Description|Accepted values|Example|Required|
+      #  |:type|Symbol|Rotation type|:one_point,:two_point|:type => :one_point|Yes|
+      #  |:radius|Integer|Radius of the rotatation in pixels|Any positive Integer|:radius => 100|Yes|
+      #  |:rotation_direction|Symbol|Rotation direction|:Clockwise, :CounterClockwise|:rotate_direction => :Clockwise|Yes|
+      #  |:distance|Integer|Rotation distance in degrees|0-360|:distance => 90|Yes|
+      #  |:speed|Integer|Speed of the gesture in seconds|Positive Integer|:speed => 2|Yes|
+      #  |:direction|Integer/Symbol|The start angle of the rotation.|0-360 or :Horizontal, :Vertical|:direction => 35|Yes|
+      #  |:x|Integer|X coordinate of the center point for the pinch (relative to the object). Optional defaults to center point but if set y must also be set.|Positive Integer|:x => 50|No|
+      #  |:y|Integer|Y coordinate of the center point for the pinch (relative to the object). Optional defaults to center point but if set x must also be set.|Positive Integer|:y => 120|No|
+      #	  
+      #
+      # == returns
+      # NilClass
+      #   description: -
+      #   example: -
+      #
+      # == exceptions
+      #
+      # ArgumentError
+      #  description:  In case the given parameters are not valid.
+      #    
+	    def rotate(params)
+		    begin
+		      verify_rotate_params!(params)
+
+		      time = params[:speed].to_f
+		      speed = time*1000
+		      params[:speed] = speed.to_i
+
+		      if params[:x].kind_of?(Integer) and params[:y].kind_of?(Integer)
+			    params[:useCoordinates] = 'true' 
+			    params[:x] = attribute('x_absolute').to_i + params[:x]
+			    params[:y] = attribute('y_absolute').to_i + params[:y]
+		      end
+
+		      command = command_params #in qt_behaviour           
+		      command.command_name('Rotate')
+		      command.command_params(params)
+		      
+		      @sut.execute_command( command )
+		      
+		      #wait untill the operation to finish
+		      do_sleep(time)
+		    rescue Exception => e      
+		      MobyUtil::Logger.instance.log "behaviour","FAIL;Failed rotate with params \"#{params.to_s}\".;#{identity};rotate;"
+		      Kernel::raise e        
+		    end      
+		    MobyUtil::Logger.instance.log "behaviour","PASS;Operation rotate succeeded with params \"#{params.to_s}\".;#{identity};rotate;"
+		    nil
+	    end
+
+    private
+
+	    def verify_rotate_params!(params)
+		    raise ArgumentError.new( "Invalid type allowed valued(:sector, :acrs)." ) unless params[:type] == :one_point or params[:type] == :two_point
+		    raise ArgumentError.new("Speed must be a number.") unless params[:speed].kind_of?(Numeric)
+
+		    #direction
+		    if params[:direction].kind_of?(Integer)
+		      raise ArgumentError.new("Direction must be between 0 and 360.") unless params[:direction] >= 0 and params[:direction] < 360
+		    else    
+		      raise ArgumentError.new( "Invalid direction." ) unless @@_pinch_directions.include?(params[:direction])  
+		      params[:direction] = @@_pinch_directions[params[:direction]]
+		    end
+
+		    raise ArgumentError.new("Distance must be an integer.") unless params[:distance].kind_of?(Integer)   
+		    raise ArgumentError.new("Distance must be between 0 and 360") unless params[:distance] > 0 and params[:distance] <= 360
+
+		    raise ArgumentError.new("Invalid direction must be " + @@_rotate_direction.to_s) unless @@_rotate_direction.include?(params[:rotate_direction])
+		    raise ArgumentError.new("Radius must be an integer.") unless params[:radius].kind_of?(Integer)
+	    end
+
+	    def verify_pinch_params!(params)
+		    #type
+		    raise ArgumentError.new( "Invalid type allowed valued(:in, :out)." ) unless params[:type] == :in or params[:type] == :out
+		    #speed 
+		    raise ArgumentError.new("Speed must be a number.") unless params[:speed].kind_of?(Numeric)
+		    #distance
+		    raise ArgumentError.new("Distance 1 must be an integer.") unless params[:distance_1].kind_of?(Integer)
+		    raise ArgumentError.new("Distance 2 must be an integer.") unless params[:distance_2].kind_of?(Integer)
+		    #direction
+		    if params[:direction].kind_of?(Integer)
+		      raise ArgumentError.new( "Invalid direction." ) unless 0 <= params[:direction].to_i and params[:direction].to_i <= 180 
+		    else    
+		      raise ArgumentError.new( "Invalid direction." ) unless @@_pinch_directions.include?(params[:direction])  
+		      params[:direction] = @@_pinch_directions[params[:direction]]
+		    end
+		    #differential
+		    raise ArgumentError.new("Differential must be an integer.") unless params[:differential].kind_of?(Integer)
+	    end
+
+	    # enable hooking for performance measurement & debug logging
+	    MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+
+	  end # Multitouch
+
+  end # QT
+
+end # MobyBehaviour