testability-driver-qt-sut-plugin 1.2.1 → 1.3.0

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

@@ -517,7 +517,7 @@ module MobyBehaviour
       #
       # duration
       #  Numeric
-      #   description: Duration of the gesture in seconds. The value may be an interger or a fractional value as a floating point number.
+      #   description: Duration of the gesture in seconds. The value may be an integer or a fractional value as a floating point number.
       #   example: 1
       #
       # mouse_details
@@ -540,59 +540,87 @@ 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 = {}, 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
+          # verify that "duration" argument type is correct 
+          duration.check_type [ Fixnum, Float ], 'wrong argument type $1 for duration value (expected $2)'
 
-          optional_params[:useTapScreen] = use_tap_screen
+          # verify that "points" argument type is correct 
+          points.check_type Array, 'wrong argument type $1 for gesture points array (expected $2)'
+
+          # verify that "mouse_details" argument type is correct 
+          mouse_details.check_type Hash, 'wrong argument type $1 for mouse details hash (expected $2)'
 
-          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)
+          # verify that "optional_params" argument type is correct 
+          optional_params.check_type Hash, 'wrong argument type $1 for optional parameters hash (expected $2)'
 
-          raise ArgumentError.new( "Invalid button." ) unless @@_valid_buttons.include?(mouse_details[:button])
+          # set default values unless given by caller
+          mouse_details.default_values(
+          
+            :press => true, 
+            :release => true, 
+            :button => :Left, 
+            :isDrag => true
+          
+          )
 
-          command = command_params #in qt_behaviour           
-          command.command_name('MouseGesturePoints')
-          params = {'mouseMove'=>'true'}
+          # verify that given button is valid
+          mouse_details[ :button ].validate @@_valid_buttons, 'unsupported button $3 for gesture points (expected $2)'
+          
+          # initialize command parameters class
+          command = command_params # in qt_behaviour
+          
+          # set command name
+          command.command_name( 'MouseGesturePoints' )
+          
+          # set command parameters
+          command.command_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)
-              
+            {
+          
+              'mouseMove'    => true,    
+              'button'       => @@_buttons_map[ mouse_details[ :button ] ],
+              'press'        => mouse_details[ :press ].true?,
+              'release'      => mouse_details[ :release ].true?,
+              'isDrag'       => mouse_details[ :isDrag ].true?,
+              'speed'        => ( duration.to_f * 1000 ).to_i,
+              'useTapScreen' => ( optional_params.delete( :use_tap_screen ) || sut_parameters[ :use_tap_screen, false ] ).true?
 
-          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)
+            }.merge!( optional_params )
 
-          @sut.execute_command(command)
+          )
+          
+          # collect points as string
+          command.command_value(
+          
+             points.inject(""){ | result, point | 
+             
+              result << "#{ point['x'].to_s },#{ point['y'].to_s },#{ (point['interval']*1000).to_i.to_s };"
+              
+            }
+            
+          )
+          
+          # execute the command
+          execute_behavior(optional_params, command)
 
-          do_sleep(duration)
+          # wait until duration is exceeded
+          do_sleep duration.to_f
 
-        rescue Exception => e
+        rescue
 
-          $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        
+          $logger.behaviour "FAIL;Failed gesture_points with points #{ points.inspect }, duration #{ duration.inspect }, mouse_details #{ mouse_details.inspect }.;#{ identity };gesture_points;"
+          
+          raise        
 
         end      
 
-        $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;"
+        $logger.behaviour "PASS;Operation gesture_points executed successfully with points #{ points.inspect }, duration #{ duration.inspect }, mouse_details #{ mouse_details.inspect }.;#{ identity };gesture_points;"
 
         self
+        
       end
 
       # == description
@@ -855,8 +883,7 @@ module MobyBehaviour
         self
 
       end
-       
-
+      
       # == nodoc
       # utility function for getting the x coordinate of the center of the object, should this be private method?
       def object_center_x
@@ -876,62 +903,89 @@ module MobyBehaviour
       # to the sut. 
       # gesture_type: :MouseGesture, :MouseGestureTo, :MouseGestureToCoordinates
       # params = {:direction => :Up, duration => 2, :distance =>100, :isDrag =>false, :isMove =>false }
-      def do_gesture(params)
+      def do_gesture( params )
 
-        validate_gesture_params!(params)
+        validate_gesture_params!( params )
 
-        if attribute('objectType') == 'Embedded' or attribute('objectType') == 'Web'
+        object_type = attribute('objectType')
+        
+        if object_type == 'Embedded' or object_type == 'Web'
           params['obj_x'] = center_x
           params['obj_y'] = center_y
           params['useCoordinates'] = 'true'
         end
 
         command = command_params #in qt_behaviour           
-        command.command_name(params[:gesture_type].to_s)
+
+        command.command_name( params[:gesture_type].to_s )
+
         command.command_params( params )
-        @sut.execute_command( command )
+
+        execute_behavior(params, command)
+
       end
 
-      def 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 
+
+            raise ArgumentError.new( "Invalid direction." ) unless 0 <= params[:direction] and params[:direction] <= 360 
+
           else
-          raise ArgumentError.new( "Invalid direction." ) unless @@_valid_directions.include?(params[:direction])  
-          params[:direction] = @@_direction_map[params[:direction]]
+
+            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]
+
+          raise ArgumentError.new("targetId and targetType must be defined.") unless params.has_key?(:targetId) and params.has_key?(:targetType)
+
         end        
 
+        if 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)
+  
+        end
+
         #duration/speed 
-        params[:speed] = params[:speed].to_f unless params[:speed].kind_of?(Numeric)
+        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
+
+        params[:speed] = ( params[ :speed ].to_f * 1000 ).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
 
-      def do_sleep(time)
+      def do_sleep( time )
 
         if sut_parameters[ :sleep_disabled, nil ] != true
 
@@ -945,32 +999,34 @@ module MobyBehaviour
 
         else
 
-          # store the biggest value which will then be used in multitouch situations to sleep
+          # store the biggest value which will be used in multitouch situations to sleep
           sut_parameters[ :skipped_sleep_time ] = time if time > sut_parameters[ :skipped_sleep_time, 0 ]
 
         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.to_f / speed.to_f
 
       end
 
-      def distance_to_point(x, y)
+      def distance_to_point( x, y )
+
+        dist_x = x.to_i - center_x.to_i
+
+        dist_y = y.to_i - center_y.to_i
+
+        unless dist_y == 0 && dist_x == 0     
 
-        x = x.to_i
-        y = y.to_i
-        dist_x = x - center_x.to_i
-        dist_y = y - center_y.to_i
+          Math.hypot( dist_x, dist_y )
 
-        return 0 if dist_y == 0 and dist_x == 0     
-        distance = Math.hypot( dist_x, dist_y )
-        distance
+        else
+        
+          0 
+          
+        end
 
       end
 

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

@@ -323,10 +323,12 @@ module MobyBehaviour
 
         if param[ :kill ].nil?
 
-          data = {}
 
           object_xml_data, unused_rule = @test_object_adapter.get_objects( MobyUtil::XML.parse_string( xml_source ), { :type => 'Response' }, true )
 
+=begin
+          data = {}
+
           object_xml_data.collect{ | element |
           
             data.merge!( 
@@ -336,13 +338,17 @@ module MobyBehaviour
             )
 
           }
+=end
+          object_xml_data.inject( {} ){ | result, element |
+
+            result.merge!( @test_object_adapter.test_object_attributes( element ) )
 
-          data
+          }
 
         else
 
           # Killed processes have no relevant data.
-          data = {
+          {
             :status => "KILLED",
             :output => xml_source
           }
@@ -356,9 +362,9 @@ module MobyBehaviour
       # launches application in symbian device based on UID and return launched application if succesfull.
       #
       # == arguments
-      # hash_application
+      # target_application_hash
       #  Hash
-      #   description: Hash defining required expected attributes of the application
+      #   description: Hash defining expected attributes of the application
       #   example: { :UID => '' }
       #
       # == returns
@@ -370,30 +376,33 @@ module MobyBehaviour
       # TypeError
       #  description: Wrong argument type %s for attributes (expected Hash)
       #
-      def launch_with_uid( hash_uid = {} )
+      def launch_with_uid( target_application_hash = {} )
 
         begin
 
-          raise TypeError.new( "Input parameter not of Type: Hash.\nIt is: #{ hash_uid.class }" ) unless hash_uid.kind_of?( Hash )
-          the_uid =  "failed with uid:" + hash_uid[:UID].to_s
-          fullname = @sut.fixture("launch","launch_with_uid",hash_uid)
+          target_application_hash.check_type Hash, 'wrong argument type $1 for application attributes (expected: $2)'
+  
+          the_uid =  "failed with uid:" + target_application_hash[ :UID ].to_s
+
+          fullname = @sut.fixture( "launch", "launch_with_uid", target_application_hash )
           
-          if(fullname == the_uid)
-            raise fullname
-          end
-          full_shortname = fullname.rpartition('\\')[-1]
-          shortname = full_shortname.rpartition('.')[0]
-          app_child = @sut.application(:name=>shortname)
+          raise fullname if fullname == the_uid
+          
+          full_shortname = fullname.rpartition( '\\' )[ -1 ]
+          
+          shortname = full_shortname.rpartition( '.' )[ 0 ]
+          
+          app_child = @sut.application( :name => shortname )
 
-        rescue Exception
+        rescue
 
-          $logger.behaviour "FAIL;Failed to find application.;#{id.to_s};sut;{};application;" << (hash_uid.kind_of?( Hash ) ? hash_uid.inspect : hash_uid.class.to_s)
+          $logger.behaviour "FAIL;Failed to find application.;#{ id.to_s };sut;{};application;#{ target_application_hash.inspect }"
 
           raise
 
         end
 
-        $logger.behaviour "PASS;Application found.;#{id.to_s};sut;{};application;" << hash_uid.inspect
+        $logger.behaviour "PASS;Application found.;#{ id.to_s };sut;{};application;#{ target_application_hash.inspect }"
 
         app_child
 
@@ -655,7 +664,7 @@ module MobyBehaviour
       # [b]NOTE:[/b] Currently only supported on Symbian platform.
       #
       # == arguments
-      # load
+      # cpu_load
       #  Integer
       #   description: Requested CPU load in percentage.
       #   example: 50

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

@@ -48,8 +48,15 @@ module MobyBehaviour
         
       class SignalNotEmittedException < RuntimeError
     
+      end
+
+      class EventNotReceivedException < RuntimeError
+
       end
     
+      class EventsEnabledException < RuntimeError
+      end
+
       # == description
       # Synchronizes script execution to a signal. Test script execution is stopped until the expected signal is emitted or the timeout occurs. 
       # If no signals of the given type are found before the timeout an error is raised.\n
@@ -65,7 +72,11 @@ module MobyBehaviour
       #  String
       #   description: Name of the signal that is to be emitted.
       #   example: "clicked()"
-      #
+      # 
+      # params
+      #  Hash 
+      #   description: Optional parameters for wait for signal
+      #   example: "{:retry_timeout => 10, :retry_interval => 0.1}"
       # &block
       #  Proc
       #   description: Optional code block to be executed while listening signals
@@ -83,47 +94,155 @@ module MobyBehaviour
       # ArgumentError
       #  description: signal_name was not a valid String or signal_timeout was not a non negative Integer
       #
-      def wait_for_signal( signal_timeout, signal_name, &block )
+      def wait_for_signal( signal_timeout, signal_name, params = nil, &block )
+    
+        signal_timeout.check_type Integer, 'wrong argument type $1 for signal timeout (expected $2)'
+        #raise ArgumentError.new("The timeout argument was of wrong type: expected 'Integer' was '%s'" % signal_timeout.class ) unless signal_timeout.kind_of?( Integer )
     
-        Kernel::raise ArgumentError.new("The timeout argument was of wrong type: expected 'Integer' was '%s'" % signal_timeout.class ) unless signal_timeout.kind_of?( Integer )
+        signal_timeout.not_negative 'signal timeout value $1 cannot be negative'
+        #raise ArgumentError.new("The timeout argument had a value of '%s', it must be a non negative Integer.'" % signal_timeout ) unless signal_timeout >= 0
 
-        Kernel::raise ArgumentError.new("The timeout argument had a value of '%s', it must be a non negative Integer.'" % signal_timeout ) unless signal_timeout >= 0
       
-        Kernel::raise ArgumentError.new("The signal name argument was of wrong type: expected 'String' was '%s'" % signal_name.class ) unless signal_name.kind_of?( String )
+        signal_name.check_type String, 'wrong argument type $1 for signal name (expected $2)'
+        #raise ArgumentError.new("The signal name argument was of wrong type: expected 'String' was '%s'" % signal_name.class ) unless signal_name.kind_of?( String )
+      
+        signal_name.not_empty 'signal name cannot be empty'
+        #raise ArgumentError.new("The signal name argument must not be an empty String.") unless !signal_name.empty?
+
+        params.check_type [ Hash, NilClass ], 'wrong argument type $1 for signal parameters (expected $2)'
 
-        Kernel::raise ArgumentError.new("The signal name argument must not be an empty String.") unless !signal_name.empty?
-            
         # enable signal listening 
         self.fixture( 'signal', 'enable_signal', :signal => signal_name )
 
-        # execute code block if any given      
-        block.call if block_given?
+        # execute code block if any given     
+        begin
+
+          if params.kind_of?( Hash ) && params.has_key?( :retry_timeout )
+
+            MobyUtil::Retryable.until( :timeout => params[:retry_timeout], :interval => params[:retry_interval], :exception => SignalNotEmittedException) {
+
+              do_wait_signal(signal_timeout, signal_name, &block)
+
+            } 
+
+          else
+          
+            do_wait_signal(signal_timeout, signal_name, &block)
+            
+          end
+            
+        ensure
+
+          self.fixture( "signal", "remove_signals" )
+
+        end
+
+        nil
+
+      end # wait_for_signal
+
+      # == description
+      # Ensure that an event is fired into the target element
+      #
+      # [b]NOTE:[/b] Limitations: 
+      #  enable_events can not be enabled. multitouch operations are not supported.
+      #
+      # == arguments
+      # params
+      #  Hash
+      #    description: Arguments hash, see below
+      #    example: Optional paramaters, see table params below.
+      #   
+      #
+      # &block
+      #  Proc
+      #   description: Code block that triggers the event
+      #   example: @app.Button.tap
+      #
+      # == tables
+      # params
+      #  title: Hash argument params
+      #  description: Valid keys for argument tap_params as hash
+      #  |Key|Description|Type|Example|Default|
+      #  |:retry_interval|Time between retries if the event is not received|Float|2|1|
+      #  |:retry_timeout|Timeout for retry cycle|Integer|5|30|
+      #  |:sleep_time|Sleep time before fetching events from client|Foat|0.4|0.2|
+      #
+      # == returns
+      # NilClass
+      #  description: -
+      #  example: -
+      #
+      # == exceptions
+      # EventsEnabledException
+      #  description: enable_events is enabled. Event monitoring can not be enabled at the same time
+      # 
+      # EventNotReceivedException
+      #  description: Target object did not received any events defined 
+      #
+      def ensure_event(params = nil, &block)
+      
+        raise EventsEnabledException.new("enable_events is used - ensure_events can not be Used at the same time.") if @@_events_enabled
+        raise ArgumentError.new("Must be called to TestObject" ) unless self.kind_of? MobyBase::TestObject
+
+        retry_timeout = (params.nil? || params[:retry_timeout].nil?) ? 30 : params[:retry_timeout]
+        retry_interval = (params.nil? || params[:retry_interval].nil?) ? 1 : params[:retry_interval]
+        sleep_time = (params.nil? || params[:sleep_time].nil?) ? 0.2 : params[:sleep_time]
+
+        events = ['MouseButtonPress,TouchBegin,GraphicsSceneMousePress,KeyPress']
+        if params && params[:events]
+          events = params[:events]
+        end
+        app = self.get_application        
+        begin
+          app.enable_events(events, {"track_id" => self.id.to_s})
+
+          MobyUtil::Retryable.until(:timeout => retry_timeout,:interval => retry_interval, :exception => EventNotReceivedException) {
+            block.call if block_given?
+            sleep sleep_time
+            ev = app.get_events
+            begin
+              @sut.state_object(ev).events.attribute('trackedFound')
+            rescue MobyBase::AttributeNotFoundError
+              $stderr.puts "Warning: Operation not received by object #{self.id} : #{self.name}. Retrying"
+              raise EventNotReceivedException.new("No event received during call") 
+            end
+          }
+        ensure
+          app.disable_events
+        end
+      end
+
+    private
+    
+      def do_wait_signal(signal_timeout, signal_name, &block)
 
         timeout_deadline = ( Time.now + signal_timeout )
         
         signal_found = false
-            
+        
+        block.call if block_given?
+        
         while( Time.now < timeout_deadline && !signal_found )
 
           begin
+            
+            result = self.fixture( 'signal', 'get_signal' )
+            
+            signals_xml = MobyUtil::XML.parse_string( result )
+            
+            _signal_found_xml, unused_rule = @test_object_adapter.get_objects( signals_xml, { :type => 'QtSignal', :name => signal_name }, true )
 
-            signals_xml = MobyUtil::XML.parse_string( self.fixture( 'signal', 'get_signal' ) )
-			      _signal_found_xml, unused_rule = @test_object_adapter.get_objects( signals_xml, { :type => 'QtSignal', :name => signal_name}, true )
-			      signal_found = true unless _signal_found_xml.empty? 
-
+            signal_found = true unless _signal_found_xml.empty? 
+            
           end # begin
-
+          
         end # while
-      
-        # disable signal listening 
-        self.fixture( "signal", "remove_signals" )
-      
-        Kernel::raise SignalNotEmittedException.new("The signal %s was not emitted within %s seconds." % [ signal_name, signal_timeout ] ) unless signal_found
-            
-        nil
 
-      end # wait_for_signal
-    
+        raise SignalNotEmittedException, "The signal #{ signal_name } was not emitted within #{ signal_timeout } seconds." unless signal_found
+
+      end
+
       # enable hooking for performance measurement & debug logging
       TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )