testability-driver 0.9.2 → 1.0.0

data/lib/tdriver/base/errors.rb

@@ -128,4 +128,7 @@ module MobyBase
 		end
 	end
 
+	# TODO: document
+	class ApplicationNotAvailableError < MobyStandardError; end;
+
 end # MobyBase

data/lib/tdriver/base/state_object.rb

@@ -64,15 +64,18 @@ module MobyBase
 
 			end
 
-			@parent = nil
-			add_parent( parent ) unless parent.nil?
+			#@parent = nil
+			#add_parent( parent ) unless parent.nil?
+      #@parent = parent unless parent.nil?
+
+      @parent = parent 
 
 			self.xml_data= xml_element
 
-			@_child_object_cache = {}
+      @child_object_cache = TDriver::TestObjectCache.new
 
 			# Create accessor methods for any child state objects.
-			TestObjectFactory.instance.create_child_accessors!( self )
+      TDriver::TestObjectAdapter.create_child_accessors!( xml_element, self )
 
 		end
 
@@ -81,18 +84,8 @@ module MobyBase
 
 			hash_rule = method_arguments.first
 
-			# method mapping/aliases
-			case method_id
-
-				when :Button;	
-					method_id = [ :Button, :QToolButton, :DuiButton, :HbPushButton, :softkey ]
-
-				when :List;	
-					method_id = [ :QList, :HbListWidgetView, :DuiList ]
-
-			end
-
 			hash_rule = Hash.new unless hash_rule.kind_of? Hash
+
 			hash_rule[ :type ] = method_id 
 
 			begin
@@ -211,11 +204,9 @@ module MobyBase
 
 		def get_cached_test_object!( object )
 
-			object_hash = object.hash
-
-			if @_child_object_cache.has_key?( object_hash ) 
+			if @child_object_cache.has_object?( object ) 
 
-				object = @_child_object_cache[ object_hash ]
+				object = @child_object_cache[ object ]
 
 				true
 
@@ -247,7 +238,7 @@ module MobyBase
 			get_cached_test_object!( child_object ).tap{ | found_in_cache |
 
 				# add child to objects cache 
-				add_child( child_object ) unless found_in_cache
+        @child_object_cache.add_object( child_object ) unless found_in_cache
 
 			}
 

data/lib/tdriver/base/sut/controller.rb

@@ -17,7 +17,6 @@
 ## 
 ############################################################################
 
-
 module MobyBase
 
 	class SutController
@@ -28,10 +27,11 @@ module MobyBase
 		# == params
 		# sut_adapter:: MobyController::SutAdapter descendant, e.g. MobyController::QT::SutAdapter
 		# == raises
+    # TypeError:: Wrong argument type $1 for SUT controller (expected $2)
 		# NameError:: No SUT controller found for %s (%s)
 		def initialize( sut_controllers, sut_adapter )
 
-			Kernel::raise ArgumentError.new( "SUT Controller(s) must be given in String format, got #{ sut_controllers.class }" ) unless sut_controllers.kind_of? String
+      sut_controllers.check_type( String, "Wrong argument type $1 for SUT controller (expected $2)" )
 
 			@sut_adapter = sut_adapter
 
@@ -81,11 +81,11 @@ module MobyBase
 		# == returns
 		# command_data implementation specific return value
 		# == raises
-		# ArgumentError:: if command_data is not kind of MobyController::CommandData
+		# TypeError:: Wrong argument type $1 for command_data (expected $2)
 		# MobyBase::CommandNotFoundError:: if no implementation is found for the CommandData object
 		def execute_command( command_data )
 
-			Kernel::raise ArgumentError.new( 'Data not of type MobyController::CommandData' ) unless command_data.kind_of?( MobyCommand::CommandData )
+      command_data.check_type( MobyCommand::CommandData, "Wrong argument type $1 for command_data (expected $2)" )
 
 			@execution_order.each{ | controller |
 

data/lib/tdriver/base/sut/factory.rb

@@ -17,271 +17,306 @@
 ## 
 ############################################################################
 
-
 module MobyBase
 
-	# Class to create SUT objects
-	# Hides actual SUT object from the clients -> clients should be able to use the instantiated SUT object as if it was any SUT 
-	class SUTFactory
+  # Class to create SUT objects
+  # Hides actual SUT object from the clients -> clients should be able to use the instantiated SUT object as if it was any SUT 
+  class SUTFactory
 
-		include Singleton
+	include Singleton
 
-		# Initialize the singleton
-		def initialize()
+	# Initialize the singleton
+	def initialize()
 
-			reset
+	  reset
 
-		end
+	end
 
-		# Create/reset hash to store sut ids for all current suts
-		def reset
+	# Create/reset hash to store sut ids for all current suts
+	def reset
 
-			@_sut_list = {}
+	  @_sut_list = {}
 
-		end
+	end
 
-		def mapped_sut?( sut_id )
+	def mapped_sut?( sut_id )
 
-			MobyUtil::Parameter[ :mappings, {} ].has_key?( sut_id.to_sym )
-		end
+	  MobyUtil::Parameter[ :mappings, {} ].has_key?( sut_id.to_sym )
 
+	end
 
-		def get_mapped_sut( sut_id )
 
-			MobyUtil::Parameter[ :mappings ][ sut_id.to_sym ].to_sym
+	def get_mapped_sut( sut_id )
 
-		end
+	  MobyUtil::Parameter[ :mappings ][ sut_id.to_sym ].to_sym
 
-		# Function to create the actual SUT objects based on the 'sut' attribute.
-		# === params
-		# sut_type:: sut_type - sut type, supportes all types defined by SUTFactory constants
-		# id:: id - unique identifier for identifying particular SUT from each other. Is propagated to proper initializers.
-		# === returns
-		# return:: SUT object
-		# raise:: 
-		# ArgumentError:: SUT ID '%s' not found from tdriver_parameters.xml
-		def make( sut_id )
+	end
 
-			# cast into symbol just in case string was passed
-			sut_id = sut_id.to_sym
+	# Function to create the actual SUT objects based on the 'sut' attribute.
+	# === params
+	# sut_type:: sut_type - sut type, supportes all types defined by SUTFactory constants
+	# id:: id - unique identifier for identifying particular SUT from each other. Is propagated to proper initializers.
+	# === returns
+	# return:: SUT object
+	# raise:: 
+	# ArgumentError:: SUT ID '%s' not found from tdriver_parameters.xml
+	def make( sut_attributes )
 
-			sut_id = get_mapped_sut( sut_id ) if mapped_sut?( sut_id )
+      sut_id = retrieve_sut_id_from_hash( sut_attributes )
 
-			# if sut is already connected, return existing sut
-			return get_sut_from_list( sut_id ) if sut_exists?( sut_id )
+	  sut_id = get_mapped_sut( sut_id ) if mapped_sut?( sut_id )
 
-			#mapped_id = MobyUtil::Parameter[ sut_id, nil ].to_sym
+	  # if sut is already connected, return existing sut
+	  return get_sut_from_list( sut_id ) if sut_exists?( sut_id )
 
-			# check if the sut or an alias exists in tdriver_parameters.xml
-			#mapped_id = find_sut_or_mapping( sut_id )
 
-			# if sut is already connected, return existing sut
-			#return get_sut_from_list( mapped_id ) if (mapped_id != sut_id and sut_exists?( mapped_id ))
+	  # retrieve sut from parameters
+      sut = MobyUtil::Parameter[ sut_id, nil ]
 
-			Kernel::raise ArgumentError.new( "The SUT '#{ sut_id }' was not defined in TDriver parameters XML" ) if MobyUtil::Parameter[ sut_id, nil ].nil?
+	  # raise exception if sut was not found
+	  Kernel::raise ArgumentError.new( "%s not defined in TDriver parameters XML" % [ sut_id ]) if sut.nil?
+	  
+	  # retrieve sut type from parameters
+	  sut_type = sut[ :type, nil ]
+	  
+	  # raise exception if sut type was not found
+	  Kernel::raise RuntimeError.new( "SUT parameter 'type' not defined for %s in TDriver parameters/templates XML" % [ sut_id ] ) if sut_type.nil?
 
-			# retrieve sut type from parameters, raise exception if sut type was not found
-			Kernel::raise RuntimeError.new( "SUT type not defined for #{ sut_id } in TDriver parameters/templates XML" ) if ( sut_type = MobyUtil::Parameter[ sut_id ][ :type, nil ] ).nil?
+	  sut_type_symbol = sut_type.downcase.to_sym
 
-			sut_type_symbol = sut_type.downcase.to_sym
+	  # retrieve plugin name that implements given sut
+	  sut_plugin = sut[ :sut_plugin, nil ]
 
-			# retrieve plugin name that implements given sut
-			sut_plugin = MobyUtil::Parameter[ sut_id ][ :sut_plugin, nil ]
+	  sut_env = sut[ :env, '*' ]
 
-			# verify that sut plugin is defined in sut configuration
-			Kernel::raise RuntimeError.new( "SUT plugin not defined for %s (%s)" % [ sut_id, sut_type ] ) if sut_plugin.nil?
+	  # verify that sut plugin is defined in sut configuration
+	  Kernel::raise RuntimeError.new( "SUT parameter 'sut_plugin' not defined for %s (%s)" % [ sut_id, sut_type ] ) if sut_plugin.nil?
+	  
+	  # flag to determine that should exception be raised; allow one retry, then set flag to true if error still occures
+	  raise_exception = false
 
-			# flag to determine that should exception be raised; allow one retry, then set flag to true if error still occures
-			raise_exception = false
+	  begin
 
-			begin
+		# verify that sut plugin is registered
+		if MobyUtil::PluginService.instance.plugin_registered?( sut_plugin, :sut )
+		  
+		  # create sut object
+		  created_sut = MobyUtil::PluginService.instance.call_plugin_method( sut_plugin, :make_sut, sut_id )
 
-				# verify that sut plugin is registered
-				if MobyUtil::PluginService.instance.plugin_registered?( sut_plugin, :sut )
-	
-					# create sut object
-					created_sut = MobyUtil::PluginService.instance.call_plugin_method( sut_plugin, :make_sut, sut_id )
+		else
 
-				else
+		  # raise error if sut was not registered
+		  Kernel::raise NotImplementedError.new( "No plugin implementation found for SUT type: %s" % [ sut_type ] )
 
-					# raise error if sut was not registered
-					Kernel::raise NotImplementedError.new( "No plugin/implementation for SUT type: %s" % [ sut_type ] )
+		end
 
-				end
+	  rescue Exception => exception
 
-			rescue Exception => exception
+		# if sut was not registered, try to load it
+		MobyUtil::PluginService.instance.load_plugin( sut_plugin ) if exception.kind_of?( NotImplementedError )
 
-				# if sut was not registered, try to load it
-				MobyUtil::PluginService.instance.load_plugin( sut_plugin ) if exception.kind_of?( NotImplementedError )
+		if !raise_exception
 
-				if !raise_exception
+		  raise_exception = true
+		  retry 
+		  
+		else
 
-					raise_exception = true
-					retry 
-				else
+		  # still errors, raise original exception
+		  Kernel::raise exception
 
-					# still errors, raise original exception
-					Kernel::raise exception
+		end
 
-				end
+	  end
 
-			end
+	  # sut type version, default: nil    
+	  created_sut.instance_eval { 
+		@ui_type = sut_type; 
+		@ui_version = MobyUtil::Parameter[ sut_id ][ :version, nil ]; 
+		@input = MobyUtil::Parameter[ sut_id ][ :input_type, nil ]; 
+	  }
+	  
+	  # add behaviours to sut
+	  created_sut.extend( MobyBehaviour::ObjectBehaviourComposition )
 
-			# sut type version, default: nil    
-			created_sut.instance_eval { 
-				@ui_type = sut_type; 
-				@ui_version = MobyUtil::Parameter[ sut_id ][ :version, nil ]; 
-				@input = MobyUtil::Parameter[ sut_id ][ :input_type, nil ]; 
-			}
-			
-			# add behaviours to sut
-			created_sut.extend( MobyBehaviour::ObjectBehaviourComposition )
+	  # retrieve list of optional extension plugins
+	  @extension_plugins = MobyUtil::Parameter[ sut_id ][ :extension_plugins, "" ].split( ";" )
 
-			# retrieve list of optional extension plugins
-			@extension_plugins = MobyUtil::Parameter[ sut_id ][ :extension_plugins, "" ].split( ";" )
+	  # load optional extension plugins
+	  if @extension_plugins.count > 0
 
-			# load optional extension plugins
-			if @extension_plugins.count > 0
+		@extension_plugins.each{ | plugin_name |
 
-				@extension_plugins.each{ | plugin_name |
+		  raise_exception = false
 
-					raise_exception = false
+		  begin
 
-					begin
+			# verify that extension plugin is registered
+			unless MobyUtil::PluginService.instance.plugin_registered?( plugin_name, :extension )
 
-						# verify that extension plugin is registered
-						unless MobyUtil::PluginService.instance.plugin_registered?( plugin_name, :extension )
+			  # raise error if sut was not registered
+			  Kernel::raise NotImplementedError.new( "Extension plugin not found %s" % [ plugin_name ] )
 
-							# raise error if sut was not registered
-							Kernel::raise NotImplementedError.new( "Extension plugin not found %s" % [ plugin_name ] )
+			end
 
-						end
+		  rescue Exception => exception
 
-					rescue Exception => exception
+			# if sut was not registered, try to load it
+			MobyUtil::PluginService.instance.load_plugin( plugin_name ) if exception.kind_of?( NotImplementedError )
 
-						# if sut was not registered, try to load it
-						MobyUtil::PluginService.instance.load_plugin( plugin_name ) if exception.kind_of?( NotImplementedError )
+			if !raise_exception
 
-						if !raise_exception
+			  raise_exception = true
+			  retry 
+			else
 
-							raise_exception = true
-							retry 
-						else
+			  # still errors, raise original exception
+			  Kernel::raise exception
 
-							# still errors, raise original exception
-							Kernel::raise exception
+			end
 
-						end
+		  end
 
-					end
+		}
 
-				}
+	  end
 
-			end
+	  # apply sut generic behaviours
+	  created_sut.apply_behaviour!( 
+								   :object_type => [ 'sut' ], 
+#								   :sut_type => [ '*', sut_type.upcase ], 
+#								   :sut_type => [ '*', sut_type ], 
+								   :input_type => [ '*', created_sut.input.to_s ],
+								   :env => [ '*', *sut_env.to_s.split(";") ],
+								   :version => [ '*', created_sut.ui_version.to_s ]
+								   )
 
-			# apply sut generic behaviours
-			created_sut.apply_behaviour!( 
-				:object_type => [ 'sut' ], 
-				:sut_type => [ '*', sut_type.upcase ], 
-				:input_type => [ '*', created_sut.input.to_s ],
-				:version => [ '*', created_sut.ui_version.to_s ]
-			)
+	  @_sut_list[ sut_id ] = { :sut => created_sut, :is_connected => true }
 
-			@_sut_list[ sut_id ] = { :sut => created_sut, :is_connected => true }
+	  created_sut
 
-			created_sut
+	end
 
-		end
+	def disconnect_sut( sut_attributes )
 
-		def disconnect_sut( id )
+      sut_id = retrieve_sut_id_from_hash( sut_attributes )
 
-			#cast into symbol just in case string was passed
-			id = id.to_sym
-			Kernel::raise RuntimeError.new( "Not connected to device: #{ id  }" ) unless sut_exists?( id ) && @_sut_list[ id ][ :is_connected ] 
+	  Kernel::raise RuntimeError.new( 
+									 
+									 "Unable disconnect SUT due to %s is not connected" % [ sut_id ] 
+									 
+									 ) unless sut_exists?( sut_id ) && @_sut_list[ sut_id ][ :is_connected ] 
+	  
+	  @_sut_list[ sut_id ][ :sut ].disconnect
+	  
+	  @_sut_list[ sut_id ][ :is_connected ] = false
 
-			@_sut_list[ id ][ :sut ].disconnect
-			@_sut_list[ id ][ :is_connected ] = false
+	end 
 
-		end 
+	def reboot_sut( sut_attributes )
 
-		def reboot_sut( id )
+      sut_id = retrieve_sut_id_from_hash( sut_attributes )
 
-			id = id.to_sym
-			Kernel::raise RuntimeError.new( "Not connected to device: #{ id }" ) unless sut_exists?( id ) && @_sut_list[ id ][ :is_connected ]
-			
-			@_sut_list[ id ][ :sut ].reboot
-			disconnect_sut( id )
-		end
+	  Kernel::raise RuntimeError.new( 
+									 
+									 "Unable to reboot SUT due to %s is not connected" % [ sut_id ] 
+									 
+									 ) unless sut_exists?( sut_id ) && @_sut_list[ sut_id ][ :is_connected ]
+	  
+	  @_sut_list[ sut_id ][ :sut ].reboot
 
-		def connected_suts
+	  disconnect_sut( sut_id )
 
-			@_sut_list
+	end
 
-		end
+	def connected_suts
+
+	  @_sut_list
+
+	end
 
 	private
 
-		# gets sut from sut-factorys list - if not connected tries to reconnect first
-		def get_sut_from_list( id )
+    def retrieve_sut_id_from_hash( sut_attributes )
 
-			if !@_sut_list[ id ][ :is_connected ]
+	  # usability improvement: threat sut_attribute as SUT id if it is type of Symbol or String
+	  sut_attributes = { :id => sut_attributes.to_sym } if [ String, Symbol ].include?( sut_attributes.class )
 
-				@_sut_list[ id ][ :sut ].connect( id )
-				@_sut_list[ id ][ :is_connected ] = true
+      # verify that sut_attributes is type of Hash
+      sut_attributes.check_type( [ Hash, Symbol, String ], "Wrong argument type $1 for 'sut_attributes' (expected $2)" )
 
-			end
+      # legacy support: support also :Id
+      sut_attributes[ :id ] = sut_attributes.delete( :Id ) if sut_attributes.has_key?( :Id )
 
-			@_sut_list[ id ][ :sut ]
-		end
+      sut_attributes.require_key( :id, "Required SUT identification key $1 not defined in 'sut_attributes'" )
+      
+      sut_attributes[ :id ].to_sym
 
-		def sut_exists?( sut_id )
+    end
 
-			@_sut_list.has_key?( sut_id )
+	# gets sut from sut-factorys list - if not connected tries to reconnect first
+	def get_sut_from_list( id )
 
-		end
+	  if !@_sut_list[ id ][ :is_connected ]
 
-		# Finds the sut definition matching the id, either directly or via a mapping
-		#
-		# === params
-		# id:: Symbol defining the id of the sut to search for
-		# === returns
-		# Symbol:: Either id if it was found in the parameter file or the id of a sut mapped to this id, or nil if no direct or mapped match was found
-		# === raises
-		# ArgumentError:: The id argument was not a Symbol
-		def find_sut_or_mapping( id )
+		@_sut_list[ id ][ :sut ].connect( id )
+		@_sut_list[ id ][ :is_connected ] = true
 
-			Kernel::raise ArgumentError.new( "The id argument was not a Symbol." ) unless id.kind_of?( Symbol )
+	  end
 
-			begin
+	  @_sut_list[ id ][ :sut ]
+	end
 
-				# check if direct match exists
-				return id if MobyUtil::Parameter[ id ]
+	def sut_exists?( sut_id )
 
-			rescue MobyUtil::ParameterNotFoundError
+	  @_sut_list.has_key?( sut_id )
 
-				# check if a mapping is defined for the id
-				begin        
+	end
 
-					# return nil if no mapping exists
-					return nil if ( mapped_id = MobyUtil::Parameter[ :mappings ][ id ] ).nil?                
+	# Finds the sut definition matching the id, either directly or via a mapping
+	#
+	# === params
+	# sut_id:: Symbol defining the id of the sut to search for
+	# === returns
+	# Symbol:: Either id if it was found in the parameter file or the id of a sut mapped to this id, or nil if no direct or mapped match was found
+	# === raises
+	# ArgumentError:: The id argument was not a Symbol
+	def find_sut_or_mapping( sut_id )
 
-					# check if the mapped to sut id exists
-					return mapped_id if MobyUtil::Parameter[ ( mapped_id = mapped_id.to_sym ) ]
+      sut_id.check_type( Symbol, "Wrong argument type $1 for SUT id (expected $2)" )
+      
+	  #Kernel::raise ArgumentError.new( "The id argument was not a Symbol." ) unless sut_id.kind_of?( Symbol )
 
-				rescue MobyUtil::ParameterNotFoundError
+	  begin
 
-					# no mappings defined in tdriver_parameters.xml or the mapped to sut was not found
-					return nil
+		# check if direct match exists
+		return sut_id if MobyUtil::Parameter[ sut_id ]
 
-				end # check if mapping exists
+	  rescue MobyUtil::ParameterNotFoundError
 
-			end # check if direct match exists
+		# check if a mapping is defined for the id
+		begin        
 
-		end
+		  # return nil if no mapping exists
+		  return nil if ( mapped_id = MobyUtil::Parameter[ :mappings ][ sut_id ] ).nil?                
+
+		  # check if the mapped to sut id exists
+		  return mapped_id if MobyUtil::Parameter[ ( mapped_id = mapped_id.to_sym ) ]
+
+		rescue MobyUtil::ParameterNotFoundError
+
+		  # no mappings defined in tdriver_parameters.xml or the mapped to sut was not found
+		  return nil
+
+		end # check if mapping exists
+
+	  end # check if direct match exists
+
+	end
 
-		# enable hooking for performance measurement & debug logging
-		MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+	# enable hooking for performance measurement & debug logging
+	MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
 
-	end # SUTFactory
+  end # SUTFactory
 
 end # MobyBase