testability-driver-qt-sut-plugin 0.9.2

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

@@ -0,0 +1,54 @@
+############################################################################
+## 
+## 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 File.expand_path( File.join( File.dirname( __FILE__ ), 'command_data' ) )
+
+module MobyCommand
+
+	class Tap < MobyCommand::CommandData
+
+		# Constructor to Tap
+		# == params
+		# text:: (optional) String to be added to text sequence if given.
+		# == returns
+		# Instance of TypeText
+		def initialize( xcoordinate = nil, ycoordinate = nil, time_to_hold = 1, times_to_tap = 1, time_between_taps = 1 )    
+			# Set status value to nil (not executed)
+			@_xcoordinate = xcoordinate
+			@_ycoordinate = ycoordinate
+			@_time_to_hold = time_to_hold
+			@_times_to_tap = times_to_tap
+			@_time_between_taps = time_between_taps
+		end
+
+    def get_x
+      @_xcoordinate
+    end
+    def get_y
+      @_ycoordinate
+    end
+    def get_hold
+      @_time_to_hold
+    end
+
+	end
+
+end #module

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

@@ -0,0 +1,226 @@
+############################################################################
+## 
+## 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 MobyCommand
+
+	class WidgetCommand < MobyCommand::CommandData
+
+		# Constructs a new CommandParams object. CommandParams stores the details for the commands send
+		# to suts that operate using the tasCommand xml format. The controller creates an xml formatted 
+		# operation request that will be forwarded to the sut being tested. 
+		# Example:
+		# Given params: command_name = MouseClick, params = [button => '1']
+		# xml command: <Command name="MouseClick" button="1">
+		#
+		# == params
+		# command_name:: Name of the command to be executed on the device (e.g. MouseClick)
+		# params:: A Hash containing the parameters sent to the device as name/value pairs (e.g. button => 1)
+		# == returns
+		# CommandParams:: New CommandParams object
+		# == raises
+		# ArgumentError:: When the supplied params are invalid type (initially can be nil)  
+		def initialize(application_id = nil, object_id = nil, object_type = nil, command_name = nil, params = nil, value=nil, service = nil)
+
+			@@_valid_types = [ nil, :Standard, :Graphics, :Application, :Action, :Web ]
+
+			self.application_id(application_id )
+			self.object_id( object_id )
+			self.object_type( object_type )
+			self.command_name( command_name )    
+			self.command_params( params )
+			self.command_value( value )
+			self.service( service )
+	
+			@_transitions = true
+
+			return self
+
+		end
+
+		def service(service)
+			@_service = service
+		end
+
+		def get_service
+			@_service
+		end
+
+		# Set transition flag on
+		# Will cause the events to be 
+		# done on a delayed mode.
+		def transitions_on
+			@_transitions = true
+		end
+
+		# Set transition flag off
+		# Will cause the events to be 
+		# done on immediately
+		def transitions_off
+			@_transitions = false
+		end
+
+		# Return the transition value  
+		# ==returns
+		# bool: true of false  
+		def get_transitions
+			@_transitions    
+		end
+
+
+		# Set true if response is expected from device side after command
+		# Has been completed.
+		# ==params
+		# bool: True if response needed
+		def set_require_response(response_required)
+			@_response_required = response_required
+		end
+
+		# Returns true if response required after command.
+		def require_response?
+			@_response_required 
+		end
+
+		# Application id of the currently tested application
+		# == params
+		# id:: Id of the application 
+		# == returns  
+		# == raises
+		# ArgumentError:: When the supplied id is not of type String   
+		def application_id(id)
+			raise ArgumentError.new( "Application id must be a string." ) unless id == nil or id.kind_of?( String )
+			@_application_id = id
+		end
+
+		# Return application id
+		# == params  
+		# == returns
+		# String:: Application id of the command 
+		def get_application_id
+			@_application_id
+		end
+
+		# Object id of the target object
+		# == params
+		# id:: Id of the Object 
+		# == returns  
+		# == raises
+		# ArgumentError:: When the supplied id is not of type String   
+		def object_id(id)
+			raise ArgumentError.new( "Object id must be a string." ) unless id == nil or id.kind_of?( String )
+			@_object_id = id
+		end
+
+		# Return object id
+		# == params  
+		# == returns
+		# String:: Object id of the command 
+		def get_object_id
+			@_object_id
+		end
+
+		# Object type of the target object
+		# == params
+		# type:: type of the Object 
+		# == returns  
+		# == raises
+		# ArgumentError:: When the supplied type is not :Graphics or :Standard   
+		def object_type(type)
+			raise ArgumentError.new("Given object type '#{type.to_s}' is not valid.") unless @@_valid_types.include?(type)
+			@_object_type = type
+		end
+
+		# Return object type
+		# == params  
+		# == returns
+		# String:: Object type of the command 
+		def get_object_type
+			@_object_type
+		end  
+
+		# Name of the command
+		# == params
+		# name:: Name of the command to be executed on the device (e.g. MouseClick)
+		# == returns  
+		# == raises
+		# ArgumentError:: When the supplied command_name is not of type String  
+		def command_name(name)
+			raise ArgumentError.new( "Command name must be a String." ) unless name == nil or name.kind_of?( String )
+			@_command_name = name  
+		end
+
+		# Return name of the command
+		# == params  
+		# == returns
+		# String:: Name of the command 
+		def get_command_name
+			@_command_name
+		end
+
+		# Command parameters
+		# == params
+		# params:: A Hash containing the parameters sent to the device as name/value pairs (e.g. button => 1)
+		# == returns  
+		# == raises
+		# ArgumentError:: When the supplied params is of type Hash   
+		def command_params(params)
+			raise ArgumentError.new( "The given params must be in a hash (name => value)." ) unless params == nil or params.kind_of?( Hash )
+			@_command_params = params
+		end
+
+		# Return params of the command
+		# == params  
+		# == returns
+		# Hash:: Command parameter hash 
+		def get_command_params
+			@_command_params
+		end
+
+		# Command value which is passed on to the device as the value of the command.
+		# Example: <Command name=TypeText>Text to be written</Command> where the 
+		# "Text to be written" would be the value String passed as parameter to this method.
+		# == params
+		# value:: A String that will be passed to the device in the value field in the command xml, or an Array containing data for multiple step commands
+		# == returns  
+		# == raises
+		# ArgumentError:: When the supplied params not of type String or Array or nil
+		def command_value(value)
+			raise ArgumentError.new( "Command value must be a string." ) unless value == nil or value.kind_of?( String ) or value.kind_of? Array
+			@_command_value = value
+		end
+
+		# Return command value
+		# == params  
+		# == returns
+		# tring or Array:: Command value  
+		def get_command_value
+			@_command_value
+		end
+
+		def set_event_type(event_type)
+		  @_event_type = event_type
+		end
+		
+		def get_event_type		  
+		  Kernel::raise "Assert: event_type must be set!" unless @_event_type
+		  @_event_type
+		end
+	end
+end

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

@@ -0,0 +1,264 @@
+############################################################################
+## 
+## 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 MobyController
+  
+  module QT
+	
+	module Application 
+	  
+	  def set_adapter( adapter )
+		
+		@sut_adapter = adapter
+		
+	  end           
+	  
+	  # Execute the command). 
+	  # Sends the message to the device using the @sut_adapter (see base class)     
+	  # == params         
+	  # == returns
+	  # == raises
+	  # ArgumentError: raised if unsupported command type   
+	  def execute()
+		
+		return_response_crc = false
+		
+		# application ui state
+		if @_command == :State
+		  
+		  command_xml = state_message()
+		  return_response_crc = true
+		  
+		  # launch application
+		elsif @_command == :Run
+		  command_xml = run_message()
+
+		  # close
+		elsif @_command == :Close
+		  command_xml = close_message()
+
+		  # close qttas
+		elsif @_command == :CloseQttas
+		  #params = {'uid' => '0'}
+		  command_xml = make_message({:service => 'closeApplication'},'Close',{'uid' => '0'})
+
+		  # kill application
+		elsif @_command == :Kill
+		  command_xml = make_message({:service => 'closeApplication'},'Kill',{'uid' => @_application_uid})
+
+		  # list application -- raises exception??
+		elsif @_command == :List
+		  Kernel::raise ArgumentError.new( "Unknown command! " + @_command.to_s )
+
+		  # list applications		      
+		elsif @_command == :ListApps
+		  service_details = {:service => 'listApps', :name => @_application_name, :id => @_application_uid}
+		  command_xml = make_message(service_details, 'listApps', nil )
+
+		  # list crashed applications
+		elsif @_command == :ListCrashedApps
+		  service_details = {:service => 'listCrashedApps', :name => @_application_name, :id => @_application_uid}
+		  command_xml = make_message(service_details, 'listCrashedApps', nil )
+
+		  # shell command
+		elsif @_command == :Shell
+		  command_xml = make_message({:service => 'shellCommand'}, 'shellCommand', @_flags, @_application_name)
+
+		  # kill all application started by agent_qt
+		elsif @_command == :KillAll
+		  command_xml = make_message({:service =>'kill'},'Kill', nil)
+
+		  # tap screen
+		elsif @_command == :TapScreen
+		  command_xml = make_message({:service =>'tapScreen'}, 'TapScreen', params)
+
+		  # bring application to foreground
+		elsif @_command == :BringToForeground
+		  command_xml = make_message({:service => 'bringToForeground'},'BringToForeground', {'pid' => @_application_uid})
+		  
+		  # system info
+		elsif @_command == :SystemInfo
+		  command_xml = make_message({:service => 'systemInfo'}, 'systemInfo', nil)
+		  
+		  # start process memory logging
+		elsif @_command == :ProcessMemLoggingStart
+		  
+		  parameters = {
+			'thread_name' => @_application_name, 
+			'file_name' => @_flags[ :file_name ],
+			'timestamp' => @_flags[ :timestamp ],
+			'interval_s' => @_flags[ :interval_s] }
+
+		  command_xml = make_message({:service => 'resourceLogging'}, 'ProcessMemLoggingStart', parameters)
+
+
+		  # stop process memory logging
+		elsif @_command == :ProcessMemLoggingStop
+		  parameters = {'thread_name' => @_application_name,
+			'return_data' => @_flags[ :return_data ]}
+
+		  command_xml = make_message({ :service =>'resourceLogging'}, 'ProcessMemLoggingStop',paremeters)
+
+		  # start CPU load generating
+		elsif @_command == :CpuLoadStart
+		  parameters =  {'cpu_load' => @_flags[ :cpu_load ]}
+		  command_xml = make_message({:service => 'resourceLogging'},'CpuLoadStart',paremeters)
+
+		  # stop CPU load generating
+		elsif @_command == :CpuLoadStop
+		  command_xml = make_message({:service => 'resourceLogging'},'CpuLoadStop', nil)
+
+		  # unknown command
+		else
+		  Kernel::raise ArgumentError.new( "Unknown command! " + @_command.to_s )
+		end
+		
+		message = Comms::MessageGenerator.generate( command_xml )
+		@sut_adapter.send_service_request( message, return_response_crc ) if message		
+	  end
+
+	  private 
+
+	  def make_parametrized_message( service_details, command_name, params, command_params = {} )
+
+		Nokogiri::XML::Builder.new{
+		  TasCommands( service_details ) {
+			Target( :TasId => "Application" ) {
+			  Command( ( params || {} ).merge( :name => command_name ) ){
+				command_params.collect{ | name, value | 
+				  param( :name => name, :value => value ) 
+				}					        
+			  }
+			}
+		  }
+		}.to_xml
+
+	  end
+
+	  def make_message( service_details, command_name, params, command_value = nil )
+
+		Nokogiri::XML::Builder.new{
+		  TasCommands( service_details ) {
+			Target( :TasId => "Application" ) {
+			  Command( command_value || "", ( params || {} ).merge( :name => command_name ) )
+			}
+		  }
+		}.to_xml		  
+
+	  end
+
+
+	  def encode_string( source )
+		source = source.to_s
+		source.gsub!( '&', '&' );
+		source.gsub!( '>', '>' );
+		source.gsub!( '<', '&lt;' );
+		source.gsub!( '"', '&quot;' );
+		source.gsub!( '\'', '&apos;' );
+		source
+	  end
+
+	  def make_filters
+
+		params = {}
+
+		# get sut paramteres only once, store to local variable
+		sut_parameters = MobyUtil::Parameter[ @_sut.id ]
+
+		params[ 'filterProperties' ] = $last_parameter if sut_parameters[ :filter_properties, nil ]
+		params[ 'pluginBlackList'  ] = $last_parameter if sut_parameters[ :plugin_blacklist,  nil ]
+		params[ 'pluginWhiteList'  ] = $last_parameter if sut_parameters[ :plugin_whitelist,  nil ]
+
+		case sut_parameters[ :filter_type, 'none' ]
+		  
+		when 'dynamic'
+
+		  # updates the filter with the current backtrace file list
+		  MobyUtil::DynamicAttributeFilter.instance.update_filter( caller( 0 ) ) 
+
+		  white_list = MobyUtil::DynamicAttributeFilter.instance.filter_string
+		  params['attributeWhiteList'] = white_list if white_list
+		  
+		when 'static'
+
+		  params['attributeBlackList'] = $last_parameter if sut_parameters[ :attribute_blacklist, nil ]
+		  params['attributeWhiteList'] = $last_parameter if sut_parameters[ :attribute_whitelist, nil ]
+		  
+		end
+
+		params		
+
+	  end
+	  
+	  def state_message
+		app_details = { :service => 'uiState', :name => @_application_name, :id => @_application_uid }
+		app_details[ :applicationUid ] = @_refresh_args[ :applicationUid ] if @_refresh_args.include?( :applicationUid )
+		
+		case MobyUtil::Parameter[ @_sut.id ][ :filter_type, 'none' ]
+		when 'none' 
+		  command_xml = make_message( app_details, 'UiState', @_flags || {} )
+		when 'dynamic'
+		  params = @_flags || {}
+		  params[ :filtered ] = 'true'
+		  command_xml = make_parametrized_message( app_details, 'UiState', params, make_filters )
+		else
+		  command_xml = make_parametrized_message( app_details, 'UiState', @_flags || {}, make_filters )
+		end
+		command_xml		
+	  end
+
+	  def run_message
+		#clone to not make changes permanent
+		arguments = MobyUtil::Parameter[ @_sut.id ][ :application_start_arguments, "" ].clone 
+		if @_arguments
+		  arguments << "," unless arguments.empty?
+		  arguments << @_arguments
+		end
+
+		parameters = { 
+		  'application_path' => @_application_name, 
+		  'arguments' => arguments, 
+		  'environment' => @_environment, 
+		  'events_to_listen' => @_events_to_listen, 
+		  'signals_to_listen' => @_signals_to_listen, 
+		  'start_command' => @_start_command 
+		}
+
+		make_message({:service => 'startApplication'}, 'Run', parameters)				
+	  end
+
+	  def close_message
+		sut_id = @_sut.id
+
+		parameters = {
+		  'uid' => @_application_uid, 
+		  'kill' => ( @_flags || {} )[ :force_kill ] || MobyUtil::Parameter[ sut_id ][ :application_close_kill ], 
+		  'wait_time' => MobyUtil::Parameter[ sut_id ][ :application_close_wait ] 		  
+		}
+
+		make_message({:service => 'closeApplication', :id => @_application_uid }, 'Close', parameters)
+	  end
+	  
+	  # enable hooking for performance measurement & debug logging
+	  MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+	end #application
+
+  end  # QT  	
+
+end # MobyController