testability-driver 1.1.0 → 1.1.1

data/lib/tdriver/base/sut/generic/behaviours/sut.rb

@@ -679,6 +679,7 @@ module MobyBehaviour
 
         else
 
+=begin
           # execute the application control service request
           execute_command(
 
@@ -689,11 +690,30 @@ module MobyBehaviour
               self,
               target[ :arguments ],
               target[ :environment ],
+              target[ :working_directory ],
               target[ :events_to_listen ],
               target[ :signals_to_listen ]
             )
 
           )
+=end
+
+          # execute the application control service request
+          execute_command(
+            MobyCommand::Application.new(
+              :Run,
+              { 
+                :application_name => target[ :name ],
+                :application_uid => target[ :uid ],
+                :sut => self,
+                :arguments => target[ :arguments ],
+                :environment => target[ :environment ],
+                :working_directory => target[ :working_directory ],
+                :events_to_listen => target[ :events_to_listen ],
+                :signals_to_listen => target[ :signals_to_listen ]
+              }
+            )
+          )
 
         end
 
@@ -1374,12 +1394,23 @@ module MobyBehaviour
 
           else
 
+=begin
             app_command = MobyCommand::Application.new(
               :State,
               refresh_args[ :FullName ] || refresh_args[ :name ],
               refresh_args[ :id ],
               self
             )
+=end
+
+            app_command = MobyCommand::Application.new(
+              :State,
+              {
+                :application_name => refresh_args[ :FullName ] || refresh_args[ :name ],
+                :application_uid => refresh_args[ :id ],
+                :sut => self
+              }
+            )
 
             # store in case needed
             app_command.refresh_args( refresh_args )
@@ -1410,11 +1441,12 @@ module MobyBehaviour
 
       end
 
-      fetch_references( @xml_data )
-
+#      fetch_references( @xml_data )
+      @xml_data
     end
 
     # TODO: document me
+    # Usage disable for now.
     def fetch_references( xml )
 
       pids = []
@@ -1456,6 +1488,7 @@ module MobyBehaviour
 
             begin
 
+=begin
               subdata =
                 MobyUtil::XML.parse_string(
                 execute_command(
@@ -1468,6 +1501,7 @@ module MobyBehaviour
                     nil,
                     nil,
                     nil,
+                    nil,
                     {
                       'x_parent_absolute' => x_prev,
                       'y_parent_absolute' => y_prev,
@@ -1477,6 +1511,26 @@ module MobyBehaviour
                   )
                 )[ 0 ]
               )
+=end
+
+              subdata =
+                MobyUtil::XML.parse_string(
+                execute_command(
+                  MobyCommand::Application.new(
+                    :State,
+                    {
+                      :application_uid => pid,
+                      :sut => self,
+                      :flags => {
+                        'x_parent_absolute' => x_prev,
+                        'y_parent_absolute' => y_prev,
+                        'embedded' => 'true',
+                        'parent_size' => winSize
+                      }
+                    }
+                  )
+                )[ 0 ]
+              )
 
               child = subdata.root.xpath('//object')[0]
 

data/lib/tdriver/base/sut/generic/commands/application.rb

@@ -17,12 +17,244 @@
 ## 
 ############################################################################
 
-
 module MobyCommand
 
+  class Application < MobyCommand::CommandData
+  
+=begin
+    attr_reader( 
+    
+      :command_type,
+      :application_name,
+      :application_uid,
+      :sut,
+      :application_arguments,
+      :events_to_listen,
+      :signals_to_listen,
+      :working_directory,
+      :flags,
+      :start_command,
+
+      :refresh_arguments,
+      :attribute_csv_string
+
+      
+			:_arguments,
+			:_environment,
+			:_working_directory,
+			:_events_to_listen,
+			:_start_command,
+			:_application_uid,
+			:_application_name,
+			:_command,
+			:_application_name,
+			:_application_uid,
+			:_flags,
+			:_attribute_csv_string,
+			:_signals_to_listen,
+      :_sut,
+      :_refresh_args
+    
+    )
+=end
+
+    attr_reader :command_arguments
+  
+    # TODO: document me
+    def initialize( command, arguments = {} )
+        
+      arguments.check_type Hash, "wrong argument type $1 for #{ self.class } arguments (expected $2)"  
+
+      # default values
+      arguments.default = nil
+
+      @command_arguments = arguments
+  
+			self.command( command )
+			
+      # store values from arguments 
+			self.name( arguments[ :application_name ] )
+			self.uid( arguments[ :application_uid ] )
+			self.sut( arguments[ :sut ] )
+			self.arguments( arguments[ :arguments ] )
+			self.events_to_listen( arguments[ :events_to_listen ] )
+			self.signals_to_listen( arguments[ :signals_to_listen ] )
+			self.environment( arguments[ :environment ] )
+			self.working_directory( arguments[ :working_directory ] )
+			self.flags( arguments[ :flags ] )
+			self.start_command( arguments[ :start_command ] )
+	    self.refresh_args( arguments[ :refresh_arguments ] )
+			self.attribute_filter( arguments[ :attribute_filter ] )
+
+			self
+    
+    end
+
+		# Store the args for possible future use
+		def refresh_args(refresh_args={})
+		  @_refresh_args = refresh_args
+		end
+		
+		def get_refresh_args
+		  @_refresh_args
+		end
+
+
+		# Defines the type of command this Application CommandData object represents
+		# == params
+		# command_type:: Symbol, defines the command to perform on the application
+		# == returns
+		# Application:: This CommandData object
+		# == raises
+		# ArgumentError:: When the supplied command_type is invalid.
+		def command( command_type )        
+
+			@_command = command_type
+
+			self    
+
+		end  
+
+		# Defines the used SUT to be able to access parameters when creating messages
+		# == params
+		# sut:: SUT, creator of the command.
+		# == returns
+		# Application:: This CommandData object
+		# == raises
+		# ArgumentError:: When sut is not nil or a SUT
+		def sut( sut )
+
+			raise ArgumentError.new( "The given sut must be nil or a SUT." ) unless sut == nil || sut.kind_of?( MobyBase::SUT )
+			@_sut = sut
+			self
+
+		end
+
+		# Defines the name of the application this Application CommandData object is associated with
+		# == params
+		# app_name:: String, name of application to perform this command on
+		# == returns
+		# Application:: This CommandData object
+		# == raises
+		# ArgumentError:: When app_name is not nil or a String
+		def name( app_name )    
+
+			raise ArgumentError.new( "The given application name must be nil or a String." ) unless app_name == nil || app_name.kind_of?( String )        
+			@_application_name = app_name    
+			self
+
+		end
+
+		def arguments( arguments )
+
+			raise ArgumentError.new( "The given application arguments must be nil or a String." ) unless arguments == nil || arguments.kind_of?( String )   
+			@_arguments = arguments
+
+		end
+
+		def flags( flags ) 
+
+			raise ArgumentError.new( "The given application flags must be nil or a Hash." ) unless flags == nil || flags.kind_of?( Hash )   
+			@_flags = flags
+
+		end
+
+		def environment( environment )
+
+			raise ArgumentError.new( "The given application environment must be nil or a String." ) unless environment == nil || environment.kind_of?( String )   
+			@_environment = environment
+
+		end
+
+		def working_directory( working_directory )
+		
+			raise ArgumentError.new( "The given application working directory must be nil or a String." ) unless working_directory == nil || working_directory.kind_of?( String )
+			@_working_directory = working_directory
+			
+		end
+
+		def events_to_listen( events )
+
+			raise ArgumentError.new( "The events to listen must be nil or a String." ) unless events == nil || events.kind_of?( String )   
+			@_events_to_listen = events
+
+		end
+
+		def signals_to_listen( signals )
+
+			raise ArgumentError.new( "The signals to listen must be nil or a String." ) unless signals == nil || signals.kind_of?( String )   
+			@_signals_to_listen = signals
+
+		end
+		
+		def start_command( start_command )
+
+			raise ArgumentError.new( "The start_command must be nil or a String." ) unless start_command == nil || start_command.kind_of?( String )   
+			@_start_command = start_command
+
+		end
+
+		# Defines the uid of the application this Application CommandData object is associated with
+		# == params
+		# app_uid:: FixNum, uid of application to perform this command on
+		# == returns
+		# Application:: This CommandData object
+		# == raises
+		# ArgumentError:: When app_name is not nil or a String
+		def uid( app_uid )       
+
+			raise ArgumentError.new( "The given application uid must be nil, a String or an Integer." ) unless app_uid == nil || app_uid.kind_of?( String ) || app_uid.kind_of?( Fixnum )
+			@_application_uid = app_uid
+			@_application_uid = @_application_uid.to_i unless @_application_uid == nil    
+			self    
+
+		end
+
+		def get_command
+
+			@_command
+
+		end
+
+		def get_application
+
+			@_application_name
+
+		end
+
+		def get_uid
+
+			@_application_uid
+
+		end
+
+		def get_flags
+
+			@_flags
+
+		end
+
+		def attribute_filter(attribute_string)
+
+			@_attribute_csv_string = attribute_string
+
+		end
+
+		def get_attribute_filter
+
+			@_attribute_csv_string
+
+		end
+
+		# enable hooking for performance measurement & debug logging
+		TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+  
+  end
+
+=begin
+
 	class Application < MobyCommand::CommandData
 
-		#TODO: Team TE review @ Wheels
 		#Application command types 
 		#Launch application = :Run 
 		#Close application = :Close 
@@ -38,11 +270,13 @@ module MobyCommand
 		# app_uid::
 		# sut:: (optional) SUT, creator of the command. Can be used to access parameters when creating messages.
 		# arguments:: (optional) Arguments given to the application on start up. Comma separated list if more the one.
+		# environment:: (optional) Environment given to the application on start up. Comma separated list if more the one.
+		# working_directory:: (optional) Working directory for the application (not used on Symbian)
 		# == returns
 		# Application:: New CommandData object
 		# == raises
 		# ArgumentError:: When the supplied command_type is invalid.
-		def initialize( command_type = nil, app_name = nil, app_uid = nil, sut = nil, arguments = nil, environment = nil, events_to_listen = nil, signals_to_listen = nil, flags = nil, start_command = nil)
+		def initialize( command_type = nil, app_name = nil, app_uid = nil, sut = nil, arguments = nil, environment = nil, working_directory = nil, events_to_listen = nil, signals_to_listen = nil, flags = nil, start_command = nil)
 			# Set status value to nil (not executed)
 
 			self.command( command_type )
@@ -53,9 +287,10 @@ module MobyCommand
 			self.events_to_listen( events_to_listen )
 			self.signals_to_listen( signals_to_listen )
 			self.environment( environment )
+			self.working_directory( working_directory )
 			self.flags( flags )
 			self.start_command( start_command )
-		    self.refresh_args
+	    self.refresh_args
 
 			@_attribute_csv_string = nil
 
@@ -138,6 +373,13 @@ module MobyCommand
 
 		end
 
+		def working_directory( working_directory )
+		
+			raise ArgumentError.new( "The given application working directory must be nil or a String." ) unless working_directory == nil || working_directory.kind_of?( String )
+			@_working_directory = working_directory
+			
+		end
+
 		def events_to_listen( events )
 
 			raise ArgumentError.new( "The events to listen must be nil or a String." ) unless events == nil || events.kind_of?( String )   
@@ -215,5 +457,7 @@ module MobyCommand
 		TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
 	end # Application
+=end
 
 end # MobyCommand
+

data/lib/tdriver/base/sut/generic/plugin.rb

@@ -93,7 +93,7 @@ module MobyPlugin
 			TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
 			# register plugin
-			MobyUtil::PluginService.instance.register_plugin( self ) # Note: self is MobyPlugin::Generic::SUT
+			TDriver::PluginService.register_plugin( self )
 
 		end # SUT
 

data/lib/tdriver/base/test_object/adapter.rb

@@ -26,12 +26,9 @@ module TDriver
     
       private
 
-    		# special cases: allow partial match when value of type and attribute name matches
-        @@partial_match_allowed = [ 'list_item', 'text' ], [ 'application', 'fullname' ]
- 
         # TODO: document me
         def xpath_attributes( attributes, element_attributes, object_type )
-
+  
           # collect attributes
           attributes = attributes.collect{ | key, values |
 
@@ -41,20 +38,35 @@ module TDriver
               # concatenate string if it contains single and double quotes, otherwise return as is
               value = xpath_literal_string( value )
 
-              if @@partial_match_allowed.include?( [ object_type, key ] )
+              prefix_key = "@#{ key }"
+
+              if @partial_match_allowed.include?( [ object_type, key ] )
+                
+                # regexp support is needed also here
                 
                 prefix_value = "[contains(.,#{ value })]"
                 attribute_value = "contains(value/.,#{ value })"
               
               else
 
-                prefix_value = "=#{ value }"
-                attribute_value = "value/.=#{ value }"
+                if value.kind_of?( Regexp )
+                                
+                  prefix_value = "regexp_compare(#{ prefix_key },'#{ value.source }',#{ value.options })"
+                  attribute_value = "regexp_compare(value/.,'#{ value.source }',#{ value.options })"
+
+                  prefix_key = ""
+                
+                else
+                
+                  prefix_value = "=#{ value }"
+                  attribute_value = "value/.=#{ value }"
               
+                end
+                
               end
 
               # construct xpath
-              "(#{ element_attributes ? "@#{ key }#{ prefix_value } or " : "" }attributes/attribute[translate(@name,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='#{ key }' and #{ attribute_value }])"
+              "(#{ element_attributes ? "#{ prefix_key }#{ prefix_value } or " : "" }attributes/attribute[translate(@name,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='#{ key }' and #{ attribute_value }])"
      
             }.join( ' or ' ) # join attribute alternative values
                     
@@ -74,14 +86,37 @@ module TDriver
           end
           
         end # xpath_attributes
+ 
+        # TODO: document me
+        def initialize_class
+
+      		# special cases: allow partial match when value of type and attribute name matches
+          @partial_match_allowed = [ 'list_item', 'text' ], [ 'application', 'fullname' ]
+
+        end
       
     end # static
 
+    # TODO: document me
+    def self.regexp_compare( nodeset, source, options ) 
+      
+      # rebuild defined regexp, used while matching element content
+      regexp_object = Regexp.new( source.to_s, options.to_i )
+            
+      # collect all nodes matching with regexp
+      nodeset.find_all{ | node | node.content =~ regexp_object }
+    
+    end
+
     # TODO: document me
     def self.xpath_to_object( rules, find_all_children )
 
       # convert hash keys to downcased string
-      rules = Hash[ rules.collect{ | key, value | [ key.to_s.downcase, value.to_s ] } ]
+      rules = Hash[ 
+        rules.collect{ | key, value | 
+          [ key.to_s.downcase, value.kind_of?( Regexp ) ? value : value.to_s ] 
+        } 
+      ]
 
       # xpath container array
       test_object_xpath_array = []
@@ -116,6 +151,8 @@ module TDriver
     # TODO: document me
     def self.xpath_literal_string( string )
 
+      return string if string.kind_of?( Regexp )
+
       # make sure that argument is type of string
       string = string.to_s
       
@@ -176,9 +213,11 @@ module TDriver
     # TODO: document me
     def self.get_objects( source_data, rules, find_all_children )
 
+      rule = xpath_to_object( rules, find_all_children )
+
       [ 
         # perform xpath to source xml data
-        source_data.xpath( rule = xpath_to_object( rules, find_all_children ) ),
+        source_data.xpath( rule, self ),
 
         # return also created xpath  
         rule 
@@ -311,7 +350,7 @@ module TDriver
       # retrieve attribute(s) from xml
       nodeset = source_data.xpath(
        
-        "attributes/attribute[translate(@name,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='#{ attribute_name.downcase }']"
+        "attributes/attribute[translate(@name,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='#{ attribute_name.downcase }']/value"
         
       )
 
@@ -347,7 +386,7 @@ module TDriver
         # Kernel::raise MobyBase::MultipleAttributesFoundError.new( "Multiple attributes found with name '%s'" % name ) if nodeset.count > 1
 
         # return found attribute
-        nodeset.first.content.strip
+        nodeset.first.content
         
       end
 
@@ -420,12 +459,21 @@ module TDriver
         # skip if child accessor is already created 
         next if test_object.respond_to?( object_type ) 
 
-        # create child accessor method to test object unless already exists
-        test_object.instance_eval(
+        begin
+
+          # create child accessor method to test object unless already exists
+          test_object.instance_eval(
 
-          "def #{ object_type }( rules = {} ); raise TypeError,'parameter <rules> should be hash' unless rules.kind_of?( Hash ); rules[ :type ]=:#{ object_type }; child( rules ); end;"
+            "def #{ object_type }( rules = {} ); raise TypeError,'parameter <rules> should be hash' unless rules.kind_of?( Hash ); rules[ :type ]=:#{ object_type }; child( rules ); end;"
 
-        ) unless object_type.empty?
+          ) unless object_type.empty?
+
+        # in case if object type has some invalid characters, e.g. type is "ns:object"
+        rescue SyntaxError
+  
+          warn "warning: unable to create accessor to child test object whose type is #{ object_type.inspect }"
+
+        end
 
       }
 
@@ -605,6 +653,9 @@ module TDriver
     # enable hooking for performance measurement & debug logging
     TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
+    # initialize TDriver::TestObjectAdapter
+    initialize_class
+
   end # TestObjectAdapter
 
 end # TDriver