testability-driver 1.1.1 → 1.2.1

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

@@ -27,10 +27,10 @@ module MobyBase
 
     include Singleton
 
-    attr_reader :timeout
+    attr_reader :timeout, :test_object_adapter
 
     # TODO: Document me (TestObjectFactory::initialize)
-    def initialize
+    def initialize( options = {} )
 
       # get timeout from parameters, use default value if parameter not found
       @timeout = $parameters[ :application_synchronization_timeout, "20" ].to_f
@@ -38,6 +38,8 @@ module MobyBase
       # get timeout retry interval from parameters, use default value if parameter not found
       @_retry_interval = $parameters[ :application_synchronization_retry_interval, "1" ].to_f
 
+      #@test_object_adapter = TDriver::TestObjectAdapter
+
     end
 
     # Function to set timeout for TestObjectFactory
@@ -65,6 +67,9 @@ module MobyBase
       # retrieve sut object
       sut = rules[ :parent ].instance_variable_get( :@sut )
 
+      # retrieve sut objects test object adapter
+      test_object_adapter = sut.instance_variable_get( :@test_object_adapter )
+
       # search parameters for find_objects feature    
       search_parameters = make_object_search_params( rules[ :parent ], rules[ :object_attributes_hash ] )
             
@@ -90,10 +95,12 @@ module MobyBase
         :__xy_sorting => directives.has_key?( :__index ),
 
         # determine index of test object to be retrieved
-        :__index => 0
-                         
+        :__index => 0,
+        
+        :__retriable_allowed_exceptions => [ MobyBase::TestObjectNotFoundError, MobyBase::MultipleTestObjectsIdentifiedError ]
+                 
       )
-
+       
       # identify objects until desired matches found or timeout exceeds
       MobyUtil::Retryable.until( 
 
@@ -104,15 +111,18 @@ module MobyBase
         :interval => directives[ :__retry_interval ],
 
         # following exceptions are allowed; Retry until timeout exceeds or other exception type is raised
-        :exception => [ MobyBase::TestObjectNotFoundError, MobyBase::MultipleTestObjectsIdentifiedError ]
-
+        :exception => directives[ :__retriable_allowed_exceptions ]
+        
       ){
 
         # refresh sut
         sut.refresh( directives[ :__refresh_arguments ], search_parameters )
 
+        # in case of test object adapter was change during the refresh (if connected the SUT first time, see possible 'connect_after' hook from sut plugin)
+        test_object_adapter = sut.instance_variable_get( :@test_object_adapter )
+
         # retrieve objects from xml
-        matches, rule = TDriver::TestObjectAdapter.get_objects(
+        matches, rule = test_object_adapter.get_objects(
         
          rules[ :parent ].xml_data, 
          rules[ :object_attributes_hash ], 
@@ -120,14 +130,40 @@ module MobyBase
 
         )
         
+        # Temporary prevent users misleading :Text with :text (as they are different)
+        if ( rules[ :object_attributes_hash ].has_key?(:Text) )
+
+          rules[ :object_attributes_hash ][:text] = rules[ :object_attributes_hash ][:Text]
+
+        end
+        
+        # If retrying and regexp search is turned on then update the rules for text search converting it to a regex 
+        if ( 
+              matches.empty? and 
+              $parameters[ sut.id ][:elided_search, 'false'] == 'true' and 
+              rules[ :object_attributes_hash ].has_key?(:text) and
+              rules[ :object_attributes_hash ][ :text ].kind_of? String
+          )
+            text_string = rules[ :object_attributes_hash ][ :text ]
+            if ( $parameters[ sut.id ][:elided_search_with_ellipsis , 'false'] == 'true' )
+              ellipsis_char = ".*\xE2\x80\xA6"  # unicode \u2026 the ... character \xE2\x80\xA6
+            else
+              ellipsis_char = ""
+            end
+            elided_regex = Regexp.new( text_string[0..3] + ellipsis_char )
+            rules[ :object_attributes_hash ][ :text ] = elided_regex
+        end
+
         # raise exception if no matching object(s) found
         raise MobyBase::TestObjectNotFoundError, "Cannot find object with rule:\n#{ rules[ :object_attributes_hash ].inspect }" if matches.empty?
 
         # raise exception if multiple matches found and only one expected 
         if ( !directives[ :__multiple_objects ] ) && ( matches.count > 1 && !directives[ :__index_given ] )
 
+          message = "Multiple test objects found with rule: #{ rules[ :object_attributes_hash ].inspect }\nMatching objects:\n#{ list_matching_test_objects_as_list( test_object_adapter, matches ) }\n"
+
           # raise exception (with list of paths to all matching objects) if multiple objects flag is false and more than one match found
-          raise MobyBase::MultipleTestObjectsIdentifiedError, "Multiple test objects found with rule: #{ rules[ :object_attributes_hash ].inspect }\nMatching objects:\n#{ list_matching_test_objects_as_list( matches ) }\n"
+          raise MobyBase::MultipleTestObjectsIdentifiedError, message
             
         end
 
@@ -135,9 +171,9 @@ module MobyBase
         if directives[ :__xy_sorting ] == true
                   
           # sort elements
-          TDriver::TestObjectAdapter.sort_elements( 
+          test_object_adapter.sort_elements( 
             matches, 
-            TDriver::TestObjectAdapter.application_layout_direction( sut )
+            test_object_adapter.application_layout_direction( sut )
           )
 
         end
@@ -162,6 +198,12 @@ module MobyBase
     # TODO: document me
     def get_test_objects( rules )
 
+      # retrieve sut object
+      sut = rules[ :parent ].instance_variable_get( :@sut )
+
+      # retrieve sut objects test object adapter
+      test_object_adapter = sut.instance_variable_get( :@test_object_adapter )
+
       # store rules hash to variable
       object_attributes_hash = rules[ :object_attributes_hash ].clone
 
@@ -243,29 +285,29 @@ module MobyBase
       MobyUtil::DynamicAttributeFilter.instance.add_attributes( object_attributes_hash.keys )
 
       child_objects = identify_object( rules ).collect{ | test_object_xml |
+
+        # in case of test object adapter was change during the refresh (if connected the SUT first time, see possible 'connect_after' hook from sut plugin)
+        test_object_adapter = sut.instance_variable_get( :@test_object_adapter )
                 
         # create parent application test object if none defined in rules; most likely the call is originated from SUT#child, but not by using SUT#application
         unless identification_directives.has_key?( :__parent_application ) || rules.has_key?( :parent_application )
               
           # retrieve application test object xml element
-          application_test_object_xml = TDriver::TestObjectAdapter.retrieve_parent_application( test_object_xml )
+          application_test_object_xml = test_object_adapter.retrieve_parent_application( test_object_xml )
 
           unless application_test_object_xml.nil?
 
-            # retrieve sut object
-            sut = rules[ :parent ].instance_variable_get( :@sut )
-
             # retrieve test object id from xml
-            object_id = TDriver::TestObjectAdapter.test_object_element_attribute( application_test_object_xml, 'id' ){ nil }.to_i
+            object_id = test_object_adapter.test_object_element_attribute( application_test_object_xml, 'id', nil ).to_i
 
             # retrieve test object name from xml
-            object_name = TDriver::TestObjectAdapter.test_object_element_attribute( application_test_object_xml, 'name' ){ nil }.to_s
+            object_name = test_object_adapter.test_object_element_attribute( application_test_object_xml, 'name', nil ).to_s
 
             # retrieve test object type from xml
-            object_type = TDriver::TestObjectAdapter.test_object_element_attribute( application_test_object_xml, 'type' ){ nil }.to_s 
+            object_type = test_object_adapter.test_object_element_attribute( application_test_object_xml, 'type', nil ).to_s 
               
             # calculate object cache hash key
-            hash_key = TDriver::TestObjectAdapter.test_object_hash( object_id, object_type, object_name )
+            hash_key = test_object_adapter.test_object_hash( object_id, object_type, object_name )
               
             parent_cache = sut.instance_variable_get( :@child_object_cache )                       
             
@@ -281,8 +323,11 @@ module MobyBase
             
                 :parent => sut,          
                 :parent_application => nil,
-                :xml_object => application_test_object_xml
-            
+                :xml_object => application_test_object_xml,
+
+                # object identification attributes
+                :object_attributes_hash => { :name => object_name, :type => object_type }
+
               )
               
             end
@@ -312,7 +357,9 @@ module MobyBase
           :xml_object => test_object_xml,
 
           # object identification attributes
-          :object_attributes_hash => object_attributes_hash
+          :object_attributes_hash => object_attributes_hash,
+
+          :identification_directives => identification_directives
 
         )
                  
@@ -325,32 +372,43 @@ module MobyBase
 
     # TODO: document me
     def make_test_object( rules )
-                  
+
       # get parent object from hash
       parent = rules[ :parent ]
 
       # retrieve sut object
       sut = parent.instance_variable_get( :@sut )
+
+      # retrieve sut objects test object adapter
+      #test_object_adapter = sut.instance_variable_get( :@sut_controller ).test_object_adapter
+      test_object_adapter = sut.instance_variable_get( :@test_object_adapter )
+
+      # retrieve sut objects test object factory
+      #test_object_factory = sut.instance_variable_get( :@sut_controller ).test_object_factory
+      test_object_factory = sut.instance_variable_get( :@test_object_factory )
       
       # xml object element      
       xml_object = rules[ :xml_object ]
 
+      # additional rules, e.g. :__no_caching
+      identification_directives = rules[ :identification_directives ] || {}
+
       # retrieve attributes
-      #TDriver::TestObjectAdapter.fetch_attributes( xml_object, [ 'id', 'name', 'type', 'env' ], false )
+      #@test_object_adapter.fetch_attributes( xml_object, [ 'id', 'name', 'type', 'env' ], false )
 
       if xml_object.kind_of?( MobyUtil::XML::Element )
 
         # retrieve test object id from xml
-        object_id = TDriver::TestObjectAdapter.test_object_element_attribute( xml_object, 'id' ){ nil }.to_i
+        object_id = test_object_adapter.test_object_element_attribute( xml_object, 'id', nil ).to_i
 
         # retrieve test object name from xml
-        object_name = TDriver::TestObjectAdapter.test_object_element_attribute( xml_object, 'name' ){ nil }.to_s
+        object_name = test_object_adapter.test_object_element_attribute( xml_object, 'name', nil ).to_s
 
         # retrieve test object type from xml
-        object_type = TDriver::TestObjectAdapter.test_object_element_attribute( xml_object, 'type' ){ nil }.to_s 
+        object_type = test_object_adapter.test_object_element_attribute( xml_object, 'type', nil ).to_s 
 
         # retrieve test object type from xml
-        env = TDriver::TestObjectAdapter.test_object_element_attribute( xml_object, 'env' ){ $parameters[ sut.id ][ :env ] }.to_s
+        env = test_object_adapter.test_object_element_attribute( xml_object, 'env' ){ $parameters[ sut.id ][ :env ] }.to_s
         
       else
       
@@ -366,7 +424,7 @@ module MobyBase
       end
       
       # calculate object cache hash key
-      hash_key = TDriver::TestObjectAdapter.test_object_hash( object_id, object_type, object_name )
+      hash_key = test_object_adapter.test_object_hash( object_id, object_type, object_name )
       
       # get reference to parent objects child objects cache
       parent_cache = rules[ :parent ].instance_variable_get( :@child_object_cache )
@@ -380,45 +438,55 @@ module MobyBase
         # store xml_object to test object
         test_object.xml_data = xml_object
 
+        # update test objects creation attributes (either cached object or just newly created child object)
+        test_object.instance_variable_get( :@creation_attributes ).merge!( rules[ :object_attributes_hash ] )
+
       else
         
         # create test object
-        test_object = MobyBase::TestObject.new( self, sut, parent, xml_object )
+        test_object = MobyBase::TestObject.new( 
+        
+          :test_object_factory => test_object_factory, #self,
+          :test_object_adapter => test_object_adapter, #@test_object_adapter,
+          :creation_attributes => rules[ :object_attributes_hash ],
+          :xml_object => xml_object,
+          :sut => sut, 
+
+          # set given parent in rules hash as parent object for new child test object    
+          :parent => parent,
 
-        #test_object.instance_variable_set( :@object_behaviours, [] )
+          # set given application test object in rules hash as parent application for new child test object
+          :parent_application => rules[ :parent_application ]
+
+        )
+
+        # temp. variable for object type
+        obj_type = object_type.clone
 
         # apply all test object related behaviours unless object type is 'application'
-        object_type << ';*' unless object_type == 'application'
+        obj_type << ';*' unless obj_type == 'application'
 
         # apply behaviours to test object
         MobyBase::BehaviourFactory.instance.apply_behaviour!(
 
           :object => test_object,
-          :object_type => [ *object_type.split(';') ], 
+          :object_type => [ *obj_type.split(';') ], 
           :input_type => [ '*', sut.input.to_s ],
           :env => [ '*', *env.to_s.split(";") ],
           :version => [ '*', sut.ui_version.to_s ]
 
         )
-        # create child accessors
-        TDriver::TestObjectAdapter.create_child_accessors!( xml_object, test_object )
-
-        # set given parent in rules hash as parent object for new child test object    
-        test_object.instance_variable_set( :@parent, parent )
 
-        # set given application test object in rules hash as parent application for new child test object
-        test_object.instance_variable_set( :@parent_application, rules[ :parent_application ] )
+        # create child accessors
+        test_object_adapter.create_child_accessors!( xml_object, test_object )
 
-        # add created test object to parents child objects cache
-        parent_cache.add_object( test_object ) 
+        # add created test object to parents child objects cache, unless explicitly disabled
+        parent_cache.add_object( test_object ) unless identification_directives[ :__no_caching ] == true
 
       end
 
       # NOTE: Do not remove object_type from object attributes hash_rule due to it is used in find_objects service!
       #rules[ :object_attributes_hash ].delete( :type )
-
-      # update test objects creation attributes (either cached object or just newly created child object)
-      test_object.instance_variable_set( :@creation_attributes, rules[ :object_attributes_hash ] )
   
       # do not make test object verifications if we are operating on the sut itself (allow run to pass)
       unless parent.kind_of?( MobyBase::SUT )
@@ -453,8 +521,12 @@ module MobyBase
         
         object_search_params = creation_attributes.clone
 
-        object_search_params[ :className  ] = object_search_params.delete( :type ) if creation_attributes.has_key?( :type )
-        object_search_params[ :objectName ] = object_search_params.delete( :name ) if creation_attributes.has_key?( :name )
+        # see below lines how to do following easier
+        #object_search_params[ :className  ] = object_search_params.delete( :type ) if creation_attributes.has_key?( :type )
+        #object_search_params[ :objectName ] = object_search_params.delete( :name ) if creation_attributes.has_key?( :name )
+
+        object_search_params.rename_key!( :type, :className ){} 
+        object_search_params.rename_key!( :name, :objectName ){}
 
         object_search_params
 
@@ -487,31 +559,15 @@ module MobyBase
     end
 
     # TODO: document me
-    def list_matching_test_objects( matches )
+    def list_matching_test_objects_as_list( test_object_adapter, matches )
 
-      matches.collect{ | object |
-          
-        path = [ object.attribute( 'type' ) ]
+      test_object_adapter.list_test_objects_as_string( matches ).each_with_index.collect{ | object, object_index | 
 
-        while object.attribute( 'type' ) != 'application' do
-        
-          # object/objects/object/../..
-          object = object.parent.parent
-          
-          path << object.attribute( 'type' )
-        
-        end
-
-        path.reverse.join( '.' )
-      
-      }.sort
-    
-    end
+        "%3s) %s" % [ object_index + 1, object ] 
 
-    # TODO: document me
-    def list_matching_test_objects_as_list( matches )
+      }.join( "\n" )
 
-      list_matching_test_objects( matches ).each_with_index.collect{ | object, object_index | "%3s) %s" % [ object_index + 1, object ] }.join( "\n" )
+      #list_matching_test_objects( matches ).each_with_index.collect{ | object, object_index | "%3s) %s" % [ object_index + 1, object ] }.join( "\n" )
 
     end
 

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

@@ -32,12 +32,11 @@ require File.expand_path( File.join( File.dirname( __FILE__ ), 'cache' ) )
 # load test object adapter
 require File.expand_path( File.join( File.dirname( __FILE__ ), 'adapter' ) )
 
+# load test object adapter
+require File.expand_path( File.join( File.dirname( __FILE__ ), 'xml/adapter' ) )
+
 # load verify ui module
 require File.expand_path( File.join( File.dirname( __FILE__ ), 'verification' ) )
 
 # load test object behaviours
 MobyUtil::FileHelper.load_modules( File.expand_path( File.join( File.dirname( __FILE__ ), 'behaviours' ) ) )
-
-# load report api for continous verification reporting purposes
-require File.expand_path( File.join( File.dirname( __FILE__ ), '../../report/report_api' ) ) if MobyUtil::Parameter[ :report_attach_continuous_verification_to_reporter, nil ]=='true'
-

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

@@ -104,7 +104,7 @@ module TDriver
                 TDriverReportAPI::tdriver_report_log("<hr />")
                 
                 $logger.enabled = logging_enabled
-                $logger.log "behaviour", "FAIL;Verification #{verify.message.nil? ? '' : '\"' << verify.message << '\" '}failed:#{e.to_s}.\n#{verify.timeout.nil? ? '' : ' using timeout ' + verify.timeout.to_s}.;#{sut.id.to_s+';sut'};{};verify_always;" << verify.expected.to_s
+                $logger.behaviour "FAIL;Verification #{verify.message.nil? ? '' : '\"' << verify.message << '\" '}failed:#{e.to_s}.\n#{verify.timeout.nil? ? '' : ' using timeout ' + verify.timeout.to_s}.;#{sut.id.to_s+';sut'};{};verify_always;" << verify.expected.to_s
 
               end
 
@@ -144,7 +144,7 @@ module TDriver
 
                 $logger.enabled = logging_enabled
                 
-                $logger.log "behaviour", "FAIL;Verification #{verify.message.nil? ? '' : '\"' << verify.message << '\" '}failed:#{e.to_s}.\n#{verify.timeout.nil? ? '' : ' using timeout ' + verify.timeout.to_s}.;#{sut.id.to_s+';sut'};{};verify_always;" << verify.expected.to_s
+                $logger.behaviour "FAIL;Verification #{verify.message.nil? ? '' : '\"' << verify.message << '\" '}failed:#{e.to_s}.\n#{verify.timeout.nil? ? '' : ' using timeout ' + verify.timeout.to_s}.;#{sut.id.to_s+';sut'};{};verify_always;" << verify.expected.to_s
 
               end
             
@@ -154,7 +154,7 @@ module TDriver
 
             $logger.enabled = logging_enabled
 
-            $logger.log "behaviour", "FAIL;Verification #{verify.message.nil? ? '' : '\"' << verify.message << '\" '}failed:#{e.to_s}.\n#{verify.timeout.nil? ? '' : ' using timeout ' + verify.timeout.to_s}.;#{sut.id.to_s+';sut'};{};verify_always;" << verify.expected.to_s
+            $logger.behaviour "FAIL;Verification #{verify.message.nil? ? '' : '\"' << verify.message << '\" '}failed:#{e.to_s}.\n#{verify.timeout.nil? ? '' : ' using timeout ' + verify.timeout.to_s}.;#{sut.id.to_s+';sut'};{};verify_always;" << verify.expected.to_s
 
             @@inside_verify = false
 

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

@@ -0,0 +1,734 @@
+############################################################################
+## 
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+## All rights reserved. 
+## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
+## 
+## This file is part of Testability Driver. 
+## 
+## 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 TDriver
+
+  module OptimizedXML
+
+    class TestObjectAdapter
+
+      # private methods and variables
+      class << self
+      
+        private
+
+          # TODO: document me
+          def xpath_attributes( attributes, element_attributes, object_type )
+    
+            # collect attributes
+            attributes = attributes.collect{ | key, values |
+
+              # allow multiple values options for attribute, e.g. object which 'text' attribute value is either '1' or '2' 
+              ( values.kind_of?( Array ) ? values : [ values ] ).collect{ | value |
+
+                # concatenate string if it contains single and double quotes, otherwise return as is
+                value = xpath_literal_string( value )
+
+                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 })"
+                
+                else
+
+                  if value.kind_of?( Regexp )
+                                  
+                    prefix_value = "regexp_compare(#{ prefix_key },'#{ value.source }',#{ value.options })"
+                    attribute_value = "regexp_compare(.,'#{ value.source }',#{ value.options })"
+
+                    prefix_key = ""
+                  
+                  else
+                  
+                    #prefix_value = "=#{ value }"
+                    #attribute_value = "text()=#{ value }"
+
+                    prefix_value = "=#{ value }"
+                    attribute_value = ".=#{ value }"
+
+                  end
+                  
+                end
+
+                # construct xpath
+                #"(#{ element_attributes ? "#{ prefix_key }#{ prefix_value } or " : "" }attr[translate(@name,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='#{ key }' and #{ attribute_value }])"
+                "(#{ element_attributes ? "#{ prefix_key }#{ prefix_value } or " : "" }attr[translate(@name,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='#{ key }' and #{ attribute_value }])"
+       
+              }.join( ' or ' ) # join attribute alternative values
+                      
+            }.join( ' and ' ) # join all required attributes
+
+            #p attributes
+
+            # return created xpath or nil if no attributes given 
+            if attributes.empty?
+            
+              # no attributes given
+              nil
+            
+            else
+            
+              # return result 
+              attributes
+            
+            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 | 
+
+            case value
+
+              # pass the value as is if type of regexp or array; array is used in localisation cases e.g. [ 'one', 'yksi', 'uno' ] # etc
+              when Regexp, Array
+
+                [ key.to_s.downcase, value ] 
+
+            else
+
+                [ key.to_s.downcase, value.to_s ] 
+
+            end
+
+          } 
+
+        ]
+
+        # xpath container array
+        test_object_xpath_array = []
+
+        # store and remove object element attributes from hash
+        object_element_attributes = rules.delete_keys!( 'name', 'type', 'parent', 'id' )
+
+        # children method may request test objects of any type
+        if object_element_attributes[ 'type' ] == '*' 
+
+          # test object with any name, type, parent and id is allowed
+          test_object_xpath_array << '@*'
+
+        else
+
+          # required attributes          
+          test_object_xpath_array << xpath_attributes( object_element_attributes, true, object_element_attributes[ 'type' ] )
+        
+        end
+
+        # additional attributes, eg. :text, :x, :y etc. 
+        test_object_xpath_array << xpath_attributes( rules, false, object_element_attributes[ 'type' ] )
+
+        # join required and additional attribute strings
+        test_object_xpath_string = test_object_xpath_array.compact.join( ' and ' )
+
+        # return any child element under current node or only immediate child element 
+        #find_all_children ? "*//obj[#{ test_object_xpath_string }]" : "obj[1]/obj[#{ test_object_xpath_string }]"
+
+        find_all_children ? ".//obj[#{ test_object_xpath_string }]" : "obj[#{ test_object_xpath_string }]"
+
+        #"*//obj[#{ test_object_xpath_string }]"
+      
+      end
+
+      # 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
+        
+        # does not contain no single quotes
+        if not string.include?("'")
+        
+          result = "'#{ string }'"
+
+        # does not contain no double quotes
+        elsif not string.include?('"')
+
+          result = "\"#{ string }\""
+
+        # contains single and double quotes  
+        else
+        
+          # open new item
+          result = ["'"]
+
+          # iterate through each character  
+          string.each_char{ | char |
+          
+            case char
+            
+              # encapsulate single quotes with double quotes
+              when "'"
+                
+                # close current item
+                result.last << char
+                
+                # add encapsulated single quote
+                result << "\"'\""
+                
+                # open new item
+                result << char
+                         
+              else
+              
+                # any other character will appended as is
+                result.last << char
+              
+            end
+
+          }  
+
+          # close last sentence
+          result.last << "'"
+              
+          # create concat clause for xpath
+          result = "concat(#{ result.join(',') })"
+            
+        end
+
+        result
+
+      end
+
+      # 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, self ),
+
+          # return also created xpath  
+          rule
+
+        ]   
+      
+      end
+
+      # TODO: document me
+      def self.test_object_hash( object_id, object_type, object_name )
+      
+        # calculate test object hash
+        ( ( ( 17 * 37 + object_id ) * 37 + object_type.hash ) * 37 + object_name.hash )
+
+      end
+
+      # Sort XML nodeset of test objects with layout direction
+      def self.sort_elements( nodeset, layout_direction = 'LeftToRight' )
+
+        # cache for x_absolute and y_absolute values; reduces dramatically number of xpath calls
+        cache = {}
+
+        # xpath pattern to be used for x_absolute attribute value
+        x_absolute_pattern = './attr[@name="x_absolute"]/text()'
+
+        # xpath pattern to be used for x_absolute attribute value
+        y_absolute_pattern = './attr[@name="y_absolute"]/text()'
+
+        # collect only nodes that has x_absolute and y_absolute attributes
+        nodeset.collect!{ | node |
+
+          # retrieve x_absolute attribute
+          x_absolute = node.at_xpath( x_absolute_pattern )
+
+          # retrieve y_absolute attribute
+          y_absolute = node.at_xpath( y_absolute_pattern )
+
+          # return unmodified nodeset if both attributes was not found 
+          if x_absolute.nil? || y_absolute.nil?
+
+            #warn("Warning: Unable to sort object set due to object type of #{ node.attribute( 'type' ).inspect } does not have \"x_absolute\" or \"y_absolute\" attribute")
+
+            return nodeset
+
+          else
+
+            # store attributes to cache for further processing
+            cache[ node ] = [ x_absolute.content.to_i, y_absolute.content.to_i ]
+
+            # return node as result
+            node
+
+          end
+
+        }.compact!.sort!{ | element_a, element_b |
+
+          # retrieve element a's attributes x and y
+          element_a_x, element_a_y = cache[ element_a ]
+
+          # retrieve element b's attributes x and y
+          element_b_x, element_b_y = cache[ element_b ]
+
+          case layout_direction
+          
+            when 'LeftToRight'
+
+              # compare elements
+              ( element_a_y == element_b_y ) ? ( element_a_x <=> element_b_x ) : ( element_a_y <=> element_b_y ) 
+
+            when 'RightToLeft'
+
+              # compare elements
+              ( element_a_y == element_b_y ) ? ( element_b_x <=> element_a_x ) : ( element_a_y <=> element_b_y ) 
+
+          else
+
+            # raise exception if layout direction it not supported 
+            Kernel::raise ArgumentError, "Unsupported layout direction #{ layout_direction.inspect }"
+
+          end
+
+        }
+
+      end
+
+      def self.parent_test_object_element( test_object )
+
+        # retrieve parent of current xml element; obj/..
+        test_object.xml_data.parent #.parent
+      
+      end
+      
+      # TODO: document me
+      def self.test_object_element_attributes( source_data )
+
+        Hash[
+          source_data.attributes.collect{ | key, value | 
+            [ key.to_s, value.to_s ]
+          }
+        ]
+
+      end
+
+      # TODO: document me
+      def self.test_object_element_attribute( source_data, attribute_name, *default, &block )
+
+        result = source_data.attribute( attribute_name )
+        
+        # if no attribute found call optional code block or raise exception 
+        unless result
+              
+          if block_given?
+            
+            # pass return value of block as result
+            yield( attribute_name )
+          
+          else
+          
+            # raise exception if no default value given
+            if default.empty?
+          
+              # raise exception if no such attribute found
+              Kernel::raise MobyBase::AttributeNotFoundError, "Could not find test object element attribute #{ attribute_name.inspect }"
+
+            else
+            
+              # pass default value as result
+              default.first
+            
+            end
+          
+          end
+        
+        else
+        
+          result
+        
+        end
+
+      end
+
+      # TODO: document me
+      def self.test_object_attribute( source_data, attribute_name, *default, &block )
+
+        # TODO: consider using at_xpath and adding text() to query string; however "downside" is that if multiple matches found only first value will be returned as result
+
+        # retrieve attribute(s) from xml
+        nodeset = source_data.xpath(
+         
+          "attr[translate(@name,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='#{ attribute_name.downcase }']"
+          
+        )
+
+        # if no attributes found call optional code block or raise exception 
+        if nodeset.empty? 
+
+          if block_given?
+
+            # pass return value of block as result
+            yield( attribute_name )
+
+          else
+
+            # raise exception if no default value given
+            if default.empty?
+            
+              # raise exception if no such attribute found
+              Kernel::raise MobyBase::AttributeNotFoundError, "Could not find attribute #{ attribute_name.inspect }" # for test object of type #{ type.to_s }"
+
+            else
+            
+              # pass default value as result
+              default.first
+            
+            end
+            
+          end # block_given?
+
+        else # not nodeset.empty?
+        
+          # attribute(s) found
+          # Need to disable this for now 
+          # Kernel::raise MobyBase::MultipleAttributesFoundError.new( "Multiple attributes found with name '%s'" % name ) if nodeset.count > 1
+
+          # return found attribute
+          nodeset.first.content
+          
+        end
+
+      end
+
+      # TODO: document me
+      def self.test_object_attributes( source_data, inclusive_filter = [] )
+        
+        # convert all keys to lowercase
+        inclusive_filter.collect!{ | key | key.to_s.downcase } unless inclusive_filter.empty?
+        
+        # return hash of test object attributes
+        Hash[ 
+
+          # iterate each attribute and collect name and value      
+          source_data.xpath( 'attr' ).collect{ | value | 
+
+            # retrieve attribute name
+            name = value.attribute('name').to_s
+
+            # collect attribute elements name and content
+            unless inclusive_filter.empty?
+            
+              [ name, value.content ] if inclusive_filter.include?( name.downcase )
+                      
+            else
+
+              # pass the attribute pair - no filtering done
+              [ name, value.content ]
+            
+            end
+
+          }
+
+        ]
+
+      end
+
+      # TODO: document me
+      def self.application_layout_direction( sut )
+
+        # temporary fix until testobject will be associated to parent application object
+        unless MobyUtil::DynamicAttributeFilter.instance.has_attribute?( 'layoutDirection' )
+          
+          # temporary fix: add 'layoutDirection' to dynamic attributes filtering whitelist...
+          MobyUtil::DynamicAttributeFilter.instance.add_attribute( 'layoutDirection' ) 
+          
+          # temporary fix: ... and refresh sut to retrieve updated xml data
+          sut.refresh
+        
+        end 
+              
+        # TODO: parent application test object should be passed to get_test_objects; TestObjectAdapter#test_object_attribute( @app.xml_data, 'layoutDirection')
+        #( sut.xml_data.at_xpath('*//obj[@type="application"]/attr[@name="layoutDirection"]/text()').content || 'LeftToRight' ).to_s
+
+        ( sut.xml_data.at_xpath('.//obj[@type="application"]/attr[@name="layoutDirection"]/text()').content || 'LeftToRight' ).to_s
+
+      end
+
+      # TODO: document me
+      def self.create_child_accessors!( source_data, test_object )
+
+        # iterate through each child object type attribute and create accessor method  
+        source_data.xpath( 'obj/@type' ).each{ | object_type |
+
+          # skip if object type value is nil or empty due to child accessor cannot be created
+          next if object_type.nil? || object_type.to_s.empty?
+
+          # convert attribute node value to string
+          object_type = object_type.content
+
+          # skip if child accessor is already created 
+          next if test_object.respond_to?( object_type ) 
+
+          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;"
+
+            ) 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
+
+        }
+
+      end
+
+      # TODO: document me
+      def self.state_object_xml( source_data, id )
+      
+        # collect each object from source xml
+        objects = source_data.xpath( 'tasInfo/obj' ).collect{ | element | element.to_s }.join
+      
+        # return xml root element
+        MobyUtil::XML.parse_string( 
+          "<sut name='sut' type='sut' id='#{ id }'>#{ objects }</sut>"
+        ).root
+      
+      end
+
+      def self.retrieve_parent_application( xml_source )
+
+        xml_source_iterator = xml_source.clone
+
+        while xml_source_iterator.kind_of?( MobyUtil::XML::Element )
+
+          if ( test_object_element_attribute( xml_source_iterator, 'type' ) == 'application' )
+
+            return xml_source_iterator
+
+          end
+
+          if xml_source_iterator.kind_of?( MobyUtil::XML::Element )
+
+            xml_source_iterator = xml_source_iterator.parent
+
+          else
+          
+            # not found from xml tree
+            break
+          
+          end
+
+        end
+
+        #warn("warning: unable to retrieve parent application")
+
+        raise MobyBase::TestObjectNotFoundError, "Unable to retrieve parent application"
+
+        # return application object or nil if no parent found
+        # Does is make sense to return nil - shouldn't all test objects belong to an application? Maybe throw exception if application not found
+        
+        #nil
+      
+        #return @sut.child( :type => 'application' ) rescue nil
+            
+      end
+      
+      # TODO: document me
+      def self.get_xml_element_for_test_object( test_object )
+        
+        # retrieve nodeset from sut xml_data
+        nodeset = test_object.instance_variable_get( :@sut ).xml_data.xpath( test_object.instance_variable_get( :@x_path ) )
+
+        # raise exception if no test objects found 
+			  Kernel::raise MobyBase::TestObjectNotFoundError if nodeset.empty?
+			
+        # return first test object from the nodeset
+			  nodeset.first
+      
+      end
+
+      # TODO: document me    
+      def self.get_test_object_identifiers( xml_source, test_object = nil )
+
+        # retrieve parent xpath if test_object given
+        parent_xpath = test_object ? test_object.instance_variable_get( :@parent ).x_path : ""
+      
+        # retrieve type attribute
+        type = xml_source.attribute( 'type' )
+
+        # retrieve id attribute
+        id = xml_source.attribute( 'id' )
+
+        # retrieve env attribute
+        env = xml_source.attribute( 'env' )
+
+        # retrieve test object element attributes and return array containting xpath to test object, name, type and id elements
+        [ 
+          # x_path to test object
+          #test_object ? "#{ parent_xpath }/*//obj[@type='#{ type }' and @id='#{ id }']" : nil,
+
+          test_object ? "#{ parent_xpath }/.//obj[@type='#{ type }' and @id='#{ id }']" : nil,
+
+          # test object name 
+          xml_source.attribute( 'name' ),
+          
+          # test object type 
+          type,
+          
+          # test object id 
+          id,
+
+          env
+          
+        ]
+
+      end
+
+      # TODO: document me
+      def self.hash_to_element_attributes( hash )
+
+        hash.collect{ | key, value | 
+
+          "#{ key.to_s }=\"#{ value.to_s }\"" 
+
+        }.join(' ')
+
+      end
+
+	    # TODO: document me
+      def self.merge_application_elements( xml_string )
+      
+        # parse the ui state xml
+        document_root = MobyUtil::XML.parse_string( xml_string ).root
+
+        # retrieve application objects as nodeset
+        nodeset = document_root.xpath('/tasMessage/tasInfo/obj')
+
+        # check if multiple application objects found
+        if nodeset.count > 1
+
+          # new header, apply original element attributes
+          new_xml = "<tasMessage #{ hash_to_element_attributes( document_root.attributes )  }><tasInfo #{ hash_to_element_attributes( nodeset.first.parent.attributes ) }>"
+
+          # flag defining that is application element already created
+          application_element_set = false
+
+          # collect environment values
+          environments = document_root.xpath('/tasMessage/tasInfo/obj[@type="application"]/@env').collect{ | attribute | attribute.to_s }
+
+          # iterate through each object found in xml
+          nodeset.each{ | object |        
+    
+            # only one application element
+            unless application_element_set
+            
+              #application_objects << object
+
+              # retrieve object attributes
+              attributes = object.attributes
+
+              # merge env to attributes hash
+              attributes['env'] = environments.join(';')
+
+              # add application object xml element to new xml string
+              new_xml << "<obj #{ hash_to_element_attributes( attributes ) }>"
+            
+              # application element is now set, no need to do it again
+              application_element_set = true
+              
+            end
+
+            # append all found elements
+            object.xpath('./*').each{ | object | new_xml << object.to_s }
+            
+          }
+
+          # multiple applications found, return merged application xml
+          new_xml << "</obj></tasInfo></tasMessage>"
+
+        else
+        
+          # only one application found, return data as is
+          xml_string
+        
+        end
+
+      end
+
+      # TODO: document me
+      def self.list_test_objects_as_string( source_data )
+
+        source_data.collect{ | object |
+            
+          path = [ object.attribute( 'type' ) ]
+
+          while object.attribute( 'type' ) != 'application' do
+          
+            # object/objects/object/../..
+            object = object.parent
+            
+            path << object.attribute( 'type' )
+          
+          end
+
+          path.reverse.join( '.' )
+        
+        }.sort
+      
+      end
+
+      # enable hooking for performance measurement & debug logging
+      TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+
+      # initialize TDriver::TestObjectAdapter
+      initialize_class
+
+    end # TestObjectAdapter
+
+  end # OptimizedXML
+
+end # TDriver