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

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

@@ -106,12 +106,12 @@ module MobyBehaviour
 
 		rescue Exception => e
 
-		  $logger.log "behaviour" , "FAIL;Failed set settings \"#{identifiers.to_s}\", \"#{values.to_s}\".;set_settings;"
+		  $logger.behaviour "FAIL;Failed set settings \"#{identifiers.to_s}\", \"#{values.to_s}\".;set_settings;"
 		  Kernel::raise e
 
 		end
 
-		$logger.log "behaviour" , "PASS;Operation set settings executed successfully \"#{identifiers.to_s}\", \"#{values.to_s}\".;set_settings;"
+		$logger.behaviour "PASS;Operation set settings executed successfully \"#{identifiers.to_s}\", \"#{values.to_s}\".;set_settings;"
 
 		nil
 	  end
@@ -159,12 +159,12 @@ module MobyBehaviour
 
 		rescue Exception => e
 
-		  $logger.log "behaviour" , "FAIL;Failed remove settings \"#{identifiers.to_s}\", \"#{setting_keys.to_s}\".;remove_settings;"
+		  $logger.behaviour "FAIL;Failed remove settings \"#{identifiers.to_s}\", \"#{setting_keys.to_s}\".;remove_settings;"
 		  Kernel::raise e
 
 		end
 
-		$logger.log "behaviour" , "PASS;Operation remove settings executed successfully \"#{identifiers.to_s}\", \"#{setting_keys.to_s}\".;remove_settings;"
+		$logger.behaviour "PASS;Operation remove settings executed successfully \"#{identifiers.to_s}\", \"#{setting_keys.to_s}\".;remove_settings;"
 
 		nil
 				  
@@ -213,12 +213,12 @@ module MobyBehaviour
 		  
 		rescue Exception => e
 
-		  $logger.log "behaviour" , "FAIL;Failed read settings \"#{identifiers.to_s}\", \"#{setting_keys.to_s}\".;read_settings;"
+		  $logger.behaviour "FAIL;Failed read settings \"#{identifiers.to_s}\", \"#{setting_keys.to_s}\".;read_settings;"
 		  Kernel::raise e
 
 		end
 
-		$logger.log "behaviour" , "PASS;Operation read settings executed successfully \"#{identifiers.to_s}\", \"#{setting_keys.to_s}\".;read_settings;"
+		$logger.behaviour "PASS;Operation read settings executed successfully \"#{identifiers.to_s}\", \"#{setting_keys.to_s}\".;read_settings;"
 
 		hash
 
@@ -260,12 +260,12 @@ module MobyBehaviour
 		  
 		rescue Exception => e
 
-		  $logger.log "behaviour" , "FAIL;Failed read all settings \"#{identifiers.to_s}\".;read_all_settings;"
+		  $logger.behaviour "FAIL;Failed read all settings \"#{identifiers.to_s}\".;read_all_settings;"
 		  Kernel::raise e
 
 		end
 
-		$logger.log "behaviour" , "PASS;Operation read all settings executed successfully \"#{identifiers.to_s}\".;read_all_settings;"
+		$logger.behaviour "PASS;Operation read all settings executed successfully \"#{identifiers.to_s}\".;read_all_settings;"
 
 		hash
 

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

@@ -18,7 +18,8 @@
 ## 
 ############################################################################
 
-require 'nokogiri'
+# use tdrivers own xml api instead of nokogiri
+#require 'nokogiri'
 
 module MobyBehaviour
 
@@ -84,12 +85,12 @@ module MobyBehaviour
         begin
           # execute the application control service request
           apps = execute_command( MobyCommand::Application.new( :ListApps ) )
-          $logger.log "behaviour", "PASS;Successfully listed applications.;#{ id };sut;{};list_apps;"
+          $logger.behaviour "PASS;Successfully listed applications.;#{ id };sut;{};list_apps;"
 
         rescue Exception => e
 
-          $logger.log "behaviour", "FAIL;Failed to list applications.;#{ id };sut;{};list_apps;"
-          Kernel::raise RuntimeError.new( "Unable to list applications: Exception: #{ e.message } (#{ e.class })" )
+          $logger.behaviour "FAIL;Failed to list applications.;#{ id };sut;{};list_apps;"
+          raise RuntimeError, "Unable to list applications: Exception: #{ e.message } (#{ e.class })"
 
         end
 
@@ -97,6 +98,39 @@ module MobyBehaviour
 
       end
 
+      # == description
+      # Returns XML list of processes running in the target.
+      # \n
+      # == arguments
+      #
+      # == returns
+      # String
+      #   description: tasMessage XML
+      #
+      # == exceptions
+      # RuntimeError
+      #   description: if getting applications list throws any exception it's converted to RuntimeError with descriptive message
+      def list_processes
+
+        apps = nil
+
+        begin
+          # execute the application control service request
+          apps = execute_command( MobyCommand::Application.new( :ListRunningProcesses ) )
+          $logger.behaviour "PASS;Successfully listed processes.;#{ id };sut;{};list_processes;"
+
+        rescue Exception => e
+
+          $logger.behaviour "FAIL;Failed to list processes.;#{ id };sut;{};list_processes;"
+          Kernel::raise RuntimeError.new( "Unable to list processes: Exception: #{ e.message } (#{ e.class })" )
+
+        end
+
+        apps     
+
+      end
+
+
       # == description
       # Returns XML list of applications and start times for applications started by qttasserver
       # \n
@@ -117,12 +151,12 @@ module MobyBehaviour
         begin
           # execute the application control service request
           apps = execute_command( MobyCommand::Application.new( :ListStartedApps ) )
-          $logger.log "behaviour", "PASS;Successfully listed applications.;#{ id };sut;{};list_started_apps;"
+          $logger.behaviour "PASS;Successfully listed applications.;#{ id };sut;{};list_started_apps;"
 
         rescue Exception => e
 
-          $logger.log "behaviour", "FAIL;Failed to list applications.;#{ id };sut;{};list_started_apps;"
-          Kernel::raise RuntimeError.new( "Unable to list started applications: Exception: #{ e.message } (#{ e.class })" )
+          $logger.behaviour "FAIL;Failed to list applications.;#{ id };sut;{};list_started_apps;"
+          raise RuntimeError, "Unable to list started applications: Exception: #{ e.message } (#{ e.class })"
 
         end
 
@@ -143,10 +177,10 @@ module MobyBehaviour
         begin
           # execute the application control service request
           apps = execute_command( MobyCommand::Application.new( :ListCrashedApps ) )
-          $logger.log "behaviour", "PASS;Successfully listed crashed applications.;#{ id };sut;{};list_crashed_apps;"
+          $logger.behaviour "PASS;Successfully listed crashed applications.;#{ id };sut;{};list_crashed_apps;"
         rescue Exception => e
-          $logger.log "behaviour", "FAIL;Failed to list crashed applications.;#{ id };sut;{};list_crashed_apps;"
-          Kernel::raise RuntimeError.new( "Unable to list crashed applications: Exception: #{ e.message } (#{ e.class })" )
+          $logger.behaviour "FAIL;Failed to list crashed applications.;#{ id };sut;{};list_crashed_apps;"
+          raise RuntimeError, "Unable to list crashed applications: Exception: #{ e.message } (#{ e.class })"
         end
 
         apps     
@@ -191,8 +225,8 @@ module MobyBehaviour
       #  description: Timeout of %s seconds reached. %s
       def execute_shell_command(command, param = { :detached => "false"} )      
 
-        Kernel::raise ArgumentError.new("The command argument must be a non empty String.") unless ( command.kind_of?( String ) and !command.empty? )
-        Kernel::raise ArgumentError.new("The parameters argumet must be a Hash.") unless ( param.kind_of?(Hash) )
+        raise ArgumentError, "The command argument must be a non empty String." unless command.kind_of?( String ) and !command.empty?
+        raise ArgumentError, "The parameters argumet must be a Hash." unless param.kind_of?( Hash )
 
         if param[:detached].nil?
           param[:detached] = "false"
@@ -207,23 +241,28 @@ module MobyBehaviour
           #pid = execute_command( MobyCommand::Application.new( :Shell, command, nil, nil, nil, nil, nil, nil, param ) ).to_i
 
           pid = execute_command( MobyCommand::Application.new( :Shell, { :application_name => command, :flags => param } ) ).to_i
-
+         
           data = "" 
           if pid != 0
             time = Time.new + timeout
             while true
+
               obj = shell_command(pid)
+
               sleep 1
-              data += obj['output']
+
+              data += obj['output'].to_s # cast to string in case of output is nil
+
               if Time.new > time
-              command_params = {:kill => 'true'}
-              command_output = shell_command(pid, command_params)['output']
-              Kernel::raise RuntimeError.new( "Timeout of #{timeout.to_s} seconds reached. #{command_output}")
+                command_params = {:kill => 'true'}
+                command_output = shell_command(pid, command_params)['output']
+                raise RuntimeError, "Timeout of #{timeout.to_s} seconds reached. #{command_output}"
               elsif obj['status'] == "RUNNING"
-              next
+                next
               else 
-              break
+                break
               end
+
             end
           end
           return data
@@ -266,77 +305,99 @@ module MobyBehaviour
       # ArgumentError
       #  description: The command argument was not a non empty String
       #
-      def shell_command(pid, param = {} )
-        Kernel::raise ArgumentError.new("pid argument should be positive integer.") unless pid.to_i > 0
+      def shell_command( pid, param = {} )
+
+        raise ArgumentError, "pid argument should be positive integer." unless pid.to_i > 0
+
         param[ :status ] = 'true'
 
-        #xml_source = execute_command( MobyCommand::Application.new( :Shell, pid.to_s, nil, nil, nil, nil, nil, nil, nil, param ) ).to_s
-        
-        xml_source = execute_command( MobyCommand::Application.new( :Shell, { :application_name => pid.to_s, :flags => param } ) ).to_s
+        xml_source = execute_command( 
+          MobyCommand::Application.new( 
+            :Shell, 
+            { 
+              :application_name => pid.to_s, 
+              :flags => param 
+            }
+           )
+        ).to_s
+
+        if param[ :kill ].nil?
 
-        if param[:kill].nil?
-          xml = Nokogiri::XML(xml_source)
           data = {}
-		  object_xml_data, unused_rule = TDriver::TestObjectAdapter.get_objects( xml, { :type => 'Response'}, true )
-		  object_xml_data.collect{ |element|
-			data.merge!(TDriver::TestObjectAdapter.test_object_attributes(element))
-		  }
-		  return data
-		else
-		  # Killed processes have no relevant data.
+
+          object_xml_data, unused_rule = @test_object_adapter.get_objects( MobyUtil::XML.parse_string( xml_source ), { :type => 'Response' }, true )
+
+          object_xml_data.collect{ | element |
+          
+            data.merge!( 
+
+              @test_object_adapter.test_object_attributes( element ) 
+
+            )
+
+          }
+
+          data
+
+        else
+
+          # Killed processes have no relevant data.
           data = {
-          :status => "KILLED",
-          :output => xml_source
+            :status => "KILLED",
+            :output => xml_source
           }
+
         end
+
       end
 
 
-  # == description
-  # launches application in symbian device based on UID and return launched application if succesfull.
-  #
-  # == arguments
-  # hash_application
-  #  Hash
-  #   description: Hash defining required expected attributes of the application
-  #   example: { :UID => '' }
-  #
-  # == returns
-  # MobyBase::Application
-  #  description: launched application that matched the uid
-  #  example: -
-  #
-  # == exceptions
-  # TypeError
-  #  description: Wrong argument type %s for attributes (expected Hash)
-  #
-  def launch_with_uid( hash_uid = {} )
-
-    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)
-      
-      if(fullname == the_uid)
-        raise fullname
-      end
-      full_shortname = fullname.rpartition('\\')[-1]
-      shortname = full_shortname.rpartition('.')[0]
-      app_child = @sut.application(:name=>shortname)
+      # == description
+      # launches application in symbian device based on UID and return launched application if succesfull.
+      #
+      # == arguments
+      # hash_application
+      #  Hash
+      #   description: Hash defining required expected attributes of the application
+      #   example: { :UID => '' }
+      #
+      # == returns
+      # MobyBase::Application
+      #  description: launched application that matched the uid
+      #  example: -
+      #
+      # == exceptions
+      # TypeError
+      #  description: Wrong argument type %s for attributes (expected Hash)
+      #
+      def launch_with_uid( hash_uid = {} )
+
+        begin
 
-    rescue Exception => e
+          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)
+          
+          if(fullname == the_uid)
+            raise fullname
+          end
+          full_shortname = fullname.rpartition('\\')[-1]
+          shortname = full_shortname.rpartition('.')[0]
+          app_child = @sut.application(:name=>shortname)
 
-      $logger.log "behaviour" , "FAIL;Failed to find application.;#{id.to_s};sut;{};application;" << (hash_uid.kind_of?(Hash) ? hash_uid.inspect : hash_uid.class.to_s)
-      Kernel::raise e
+        rescue Exception
 
-    end
+          $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.log "behaviour" , "PASS;Application found.;#{id.to_s};sut;{};application;" << hash_uid.inspect
+          raise
 
-    app_child
+        end
 
-  end
+        $logger.behaviour "PASS;Application found.;#{id.to_s};sut;{};application;" << hash_uid.inspect
+
+        app_child
+
+      end
 
       # == description
       # Returns details about the tested target. The data is platform/device specific which will make your scripts platform dependant. For devices with mobility apis the data available from them is returned and could be somewhat similar across platforms. Memory details are returned in a fixed format so they can be used and still maintain compatibility cross platforms. However it should be noted that platforms which do not support memory details will return -1 (scripts will not break but data will not be usable).
@@ -349,10 +410,13 @@ module MobyBehaviour
       def system_information
 
         # xml_source = execute_command( MobyCommand::Application.new( :SystemInfo, nil) )
+        # @sut.state_object( xml_source )
 
-        xml_source = execute_command( MobyCommand::Application.new( :SystemInfo ) )
-
-        MobyBase::StateObject.new( xml_source )            
+        @sut.state_object( 
+          execute_command( 
+            MobyCommand::Application.new( :SystemInfo ) 
+          )
+        )
 
       end
 
@@ -439,10 +503,11 @@ module MobyBehaviour
         begin 
           execute_command( command )            
           nil
-        rescue Exception => e      
+        rescue Exception
           
-          $logger.log "behaviour" , "FAIL;Failed tap_screen on coords \"#{x}:#{y}\";"
-          Kernel::raise e        
+          $logger.behaviour "FAIL;Failed tap_screen on coords \"#{ x }:#{ y }\";"
+
+          raise
           
         end      
 
@@ -462,10 +527,10 @@ module MobyBehaviour
         begin
           # execute the application control service request
           execute_command( MobyCommand::Application.new( :CloseQttas ) )
-          $logger.log "behaviour", "PASS;Successfully closed qttas.;#{ id };sut;{};close_qttas;"
+          $logger.behaviour "PASS;Successfully closed qttas.;#{ id };sut;{};close_qttas;"
         rescue Exception => e
-          $logger.log "behaviour", "FAIL;Failed to close qttas.;#{ id };sut;{};close_qttas;"
-          Kernel::raise RuntimeError.new( "Unable to close qttas: Exception: #{ e.message } (#{ e.class })" )
+          $logger.behaviour "FAIL;Failed to close qttas.;#{ id };sut;{};close_qttas;"
+          raise RuntimeError, "Unable to close qttas: Exception: #{ e.message } (#{ e.class })"
         end
         nil
       end
@@ -527,12 +592,12 @@ module MobyBehaviour
             ) 
           )
 
-          $logger.log "behaviour", "PASS;Successfully started process memory logging.;#{ id };sut;{};log_process_mem_start;"
+          $logger.behaviour "PASS;Successfully started process memory logging.;#{ id };sut;{};log_process_mem_start;"
 
         rescue Exception => e
 
-          $logger.log "behaviour", "FAIL;Failed to start process memory logging.;#{ id };sut;{};log_process_mem_start;"
-          Kernel::raise RuntimeError.new( "Unable to start process memory logging: Exception: #{ e.message } (#{ e.class })" )
+          $logger.behaviour "FAIL;Failed to start process memory logging.;#{ id };sut;{};log_process_mem_start;"
+          raise RuntimeError, "Unable to start process memory logging: Exception: #{ e.message } (#{ e.class })"
 
         end
 
@@ -568,15 +633,6 @@ module MobyBehaviour
         log = nil
         begin
 
-=begin
-          log = execute_command(
-                    MobyCommand::Application.new(
-                                   :ProcessMemLoggingStop,
-                                   thread_name,
-                                   nil, nil, nil, nil, nil, nil,
-                                   {:return_data => return_data} ) )
-=end
-
           log = execute_command(
             MobyCommand::Application.new(
               :ProcessMemLoggingStop,
@@ -584,10 +640,10 @@ module MobyBehaviour
             ) 
           )
 
-          $logger.log "behaviour", "PASS;Successfully stopped process memory logging.;#{ id };sut;{};log_process_mem_stop;"
+          $logger.behaviour "PASS;Successfully stopped process memory logging.;#{ id };sut;{};log_process_mem_stop;"
         rescue Exception => e
-          $logger.log "behaviour", "FAIL;Failed to stop process memory logging.;#{ id };sut;{};log_process_mem_stop;"
-          Kernel::raise RuntimeError.new( "Unable to stop process memory logging: Exception: #{ e.message } (#{ e.class })" )
+          $logger.behaviour "FAIL;Failed to stop process memory logging.;#{ id };sut;{};log_process_mem_stop;"
+          raise RuntimeError, "Unable to stop process memory logging: Exception: #{ e.message } (#{ e.class })"
         end
         log
       end
@@ -627,13 +683,13 @@ module MobyBehaviour
             ) 
           )
 
-          $logger.log "behaviour", "PASS;Successfully started generating CPU load.;#{ id };sut;{};cpu_load_start;"
+          $logger.behaviour "PASS;Successfully started generating CPU load.;#{ id };sut;{};cpu_load_start;"
 
         rescue Exception => e
 
-          $logger.log "behaviour", "FAIL;Failed to start generating CPU load.;#{ id };sut;{};cpu_load_start;"
+          $logger.behaviour "FAIL;Failed to start generating CPU load.;#{ id };sut;{};cpu_load_start;"
 
-          Kernel::raise RuntimeError.new( "Unable to start generating CPU load: Exception: #{ e.message } (#{ e.class })" )
+          raise RuntimeError, "Unable to start generating CPU load: Exception: #{ e.message } (#{ e.class })"
 
         end
 
@@ -652,10 +708,10 @@ module MobyBehaviour
       def cpu_load_stop
         begin
           status = execute_command(MobyCommand::Application.new(:CpuLoadStop) )
-          $logger.log "behaviour", "PASS;Successfully started generating CPU load.;#{ id };sut;{};cpu_load_start;"
+          $logger.behaviour "PASS;Successfully started generating CPU load.;#{ id };sut;{};cpu_load_start;"
         rescue Exception => e
-          $logger.log "behaviour", "FAIL;Failed to start generating CPU load.;#{ id };sut;{};cpu_load_start;"
-          Kernel::raise RuntimeError.new( "Unable to start generating CPU load: Exception: #{ e.message } (#{ e.class })" )
+          $logger.behaviour "FAIL;Failed to start generating CPU load.;#{ id };sut;{};cpu_load_start;"
+          raise RuntimeError, "Unable to start generating CPU load: Exception: #{ e.message } (#{ e.class })"
         end
       end
 
@@ -686,31 +742,31 @@ module MobyBehaviour
           interval_millis = interval*1000 # to millis
 
           # make one refresh before execution then freeze
-		  find_object_state = self.parameter[ :use_find_object, false ]
-		  self.parameter[ :use_find_object] = false 
+          find_object_state = self.parameter[ :use_find_object, false ]
+          self.parameter[ :use_find_object] = false 
 
           app.force_refresh({:id => get_application_id})
           self.freeze
 
           #disable sleep to avoid unnecessary sleeping
-		  self.parameter[ :sleep_disabled ] = true
+          self.parameter[ :sleep_disabled ] = true
 
           ret = execute_command( MobyCommand::Group.new(interval_millis.to_i, app, block ) )
 
-		  self.parameter[ :sleep_disabled ] = false
-		  self.parameter[ :use_find_object] = find_object_state
+          self.parameter[ :sleep_disabled ] = false
+          self.parameter[ :use_find_object] = find_object_state
 
           self.unfreeze
 
           # the behaviour returns the amout of behaviours
-          # sleep to avoid sending messages to the app untill the 
+          # sleep to avoid sending messages to the app until the 
           # commands have been executed
           sleep ( ret * interval )
 
-          $logger.log "behaviour", "PASS;Successfully executed grouped behaviours.;#{ id };sut;{};group_behaviours;"
+          $logger.behaviour "PASS;Successfully executed grouped behaviours.;#{ id };sut;{};group_behaviours;"
         rescue Exception => e
-          $logger.log "behaviour", "FAIL;Failed to execute grouped behaviours.;#{ id };sut;{};group_behaviours;"
-          Kernel::raise RuntimeError.new( "Unable to execute grouped behaviours: Exception: #{ e.message } (#{ e.class })" )
+          $logger.behaviour "FAIL;Failed to execute grouped behaviours.;#{ id };sut;{};group_behaviours;"
+          raise RuntimeError, "Unable to execute grouped behaviours: Exception: #{ e.message } (#{ e.class })"
         end
         nil
       end
@@ -743,8 +799,8 @@ module MobyBehaviour
 
       # == nodoc
       # {:name => '', id => '', applicationUid => ''},[ {:objectName => '' , :className => , :text =>} ,..]
-      def find_object( app_details = nil, objects = nil )
-        execute_command( MobyCommand::FindObjectCommand.new( self, app_details, objects ) )
+      def find_object( app_details = nil, objects = nil, checksum = nil )
+        execute_command( MobyCommand::FindObjectCommand.new( self, app_details, objects, checksum ) )
       end
 
       # enable hooking for performance measurement & debug logging