cutedriver-driver 2.0.0.20210120164037

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

@@ -0,0 +1,51 @@
+############################################################################
+## 
+## 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. 
+## 
+############################################################################
+
+[ 
+
+  # load test object abstract class
+  'abstract',
+
+  # load test object factory
+  'factory',
+
+  # load test object cache
+  'cache',
+
+  # load test object adapter abstraction
+  'xml/abstraction',
+
+  # load test object adapter
+  'xml/adapter',
+
+  # load test object adapter
+  'adapter',
+
+  # load verify ui module
+  'verification'
+
+].each{ | filename |
+
+  require File.expand_path( File.join( File.dirname( __FILE__ ), filename ) )
+
+}
+
+# load test object behaviours
+MobyUtil::FileHelper.load_modules( File.expand_path( File.join( File.dirname( __FILE__ ), 'behaviours' ) ) )
+

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

@@ -0,0 +1,178 @@
+
+module TDriver
+
+  module TestObjectVerification
+
+    # private variables and methods  
+    class << self
+    
+      # TODO: Document me (TestObjectFactory::check_verify_always_reporting_settings)
+      def check_verify_always_reporting_settings
+
+        @@reporter_attached = $parameters[ :report_attach_continuous_verification_to_reporter, 'false' ]
+
+        @@rcv_raise_errors = $parameters[ :report_continuous_verification_raise_errors, 'true' ]
+
+        @@rcv_fail_test_case = $parameters[ :report_continuous_verification_fail_test_case_on_error, 'true' ]
+
+        @@rvc_capture_screen = $parameters[ :report_continuous_verification_capture_screen_on_error, 'true' ]
+
+      end
+
+      # TODO: Document me (TestObjectFactory::restore_verify_always_reporting_settings)
+      def restore_global_verify_always_reporting_settings
+
+        @@reporter_attached = @@global_reporter_attached
+
+        @@rcv_raise_errors = @@rcv_global_raise_errors
+
+        @@rcv_fail_test_case = @@rcv_global_fail_test_case
+
+        @@rvc_capture_screen = @@rvc_global_capture_screen
+
+      end
+
+      def initialize_settings
+
+        # defaults
+        @@global_reporter_attached = $parameters[ :report_attach_continuous_verification_to_reporter, 'false' ]
+
+        @@rcv_global_raise_errors = $parameters[ :report_continuous_verification_raise_errors, 'true' ]
+
+        @@rcv_global_fail_test_case = $parameters[ :report_continuous_verification_fail_test_case_on_error, 'true' ]
+
+        @@rvc_global_capture_screen = $parameters[ :report_continuous_verification_capture_screen_on_error, 'true' ]
+
+        @@inside_verify = false
+
+        @@initialized = true
+
+      end
+
+      # defaults
+      @@initialized = false
+                    
+    end
+      
+    def self.verify_ui_dump( sut )
+
+      initialize_settings unless @@initialized
+
+      return if @@inside_verify
+
+      begin
+
+        @@inside_verify = true
+
+        logging_enabled = $logger.enabled
+
+        sut.verify_blocks.each do | verify |
+
+          check_verify_always_reporting_settings()
+
+          begin
+
+            $logger.enabled = false
+
+            begin
+            
+              result = verify.block.call( sut )
+
+            rescue Exception => e
+
+              if @@rcv_raise_errors == 'true' || @@reporter_attached == 'false'
+
+                raise MobyBase::ContinuousVerificationError.new(
+                  "Verification failed as an exception was thrown when the verification block was executed. #{ verify.source }\nDetails: #{ ( verify.message || "none" ) }\nNested exception:\n#{ e.inspect }"
+                )
+                
+              elsif @@reporter_attached == 'true' && @@rcv_raise_errors == 'false'
+
+                TDriverReportAPI::tdriver_report_set_test_case_status('failed') if @@rcv_fail_test_case == 'true'
+
+                if @@rvc_capture_screen == 'true'
+
+                  TDriverReportAPI::tdriver_capture_state
+
+                else
+
+                  TDriverReportAPI::tdriver_capture_state( false )
+                  
+                end
+
+                TDriverReportAPI::tdriver_report_log("Verification failed as an exception was thrown when the verification block was executed. #{ verify.source }\nDetails: #{( verify.message || "none" ) }\nNested exception:\n#{ e.inspect }")
+
+                TDriverReportAPI::tdriver_report_log("<hr />")
+                
+                $logger.enabled = logging_enabled
+                $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
+
+            end
+
+            unless result == verify.expected
+
+              if @@rcv_raise_errors == 'true' || @@reporter_attached == 'false'
+              
+                raise MobyBase::ContinuousVerificationError.new(
+                  "Verification failed. #{ verify.source }\nDetails: #{ ( verify.message || "none" ) }\nThe block did not return #{ verify.expected.inspect }. It returned: #{ result.inspect }"
+                )
+                
+              elsif @@reporter_attached == 'true' && @@rcv_raise_errors == 'false'
+              
+                TDriverReportAPI::tdriver_report_set_test_case_status('failed') if @@rcv_fail_test_case == 'true'
+                
+                if @@rvc_capture_screen == 'true'
+
+                  TDriverReportAPI::tdriver_capture_state
+
+                else
+
+                  TDriverReportAPI::tdriver_capture_state( false )
+
+                end
+                
+                TDriverReportAPI::tdriver_report_log(
+                  "Verification failed. #{ verify.source }\nDetails: #{ ( verify.message || "none" ) }\nThe block did not return #{ verify.expected.inspect }. It returned: #{ result.inspect } "
+                )
+                
+                TDriverReportAPI::tdriver_report_log("<hr />")
+
+                $logger.enabled = logging_enabled
+                
+                $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
+            
+            end
+
+          rescue Exception => e
+
+            $logger.enabled = logging_enabled
+
+            $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
+
+            raise e
+          
+          end
+
+          # Do NOT report PASS cases, like other verify blocks do. This would clog the log with useless info.
+          restore_global_verify_always_reporting_settings
+        
+        end
+
+      ensure
+
+        $logger.enabled = logging_enabled
+        @@inside_verify = false      
+
+      end
+      
+    end # verify_ui
+      
+  end # TestObjectVerification
+
+end # TDriver

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

@@ -0,0 +1,63 @@
+############################################################################
+## 
+## 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 Abstraction
+  
+    module TestObjectAdapter
+
+      # TODO: document me
+      def identify_test_object_adapter_from_data( source )
+   
+        # verify check that source data is given in correct format
+        source.check_type [ String, MobyUtil::XML::Element ], 'wrong argument type $1 for XML data source (expected $2)'
+
+        # parse if given source is type of string    
+        source = MobyUtil::XML.parse_string( source ).root if source.kind_of?( String )
+
+        # determine xml format        
+        if source.kind_of?( MobyUtil::XML::Element )
+
+          # detect optimized xml format
+          if source.xpath('.//obj[1]').count > 0
+
+            TDriver::OptimizedXML::TestObjectAdapter
+          
+          # or deprecated xml format
+          elsif source.xpath('.//object[1]').count > 0
+
+            TDriver::TestObjectAdapter
+          
+          # or raise exception if format was not detected
+          else
+          
+            raise RuntimeError, 'Unsupported XML data format'
+
+          end
+                  
+        end # if
+      
+      end # identify_test_object_adapter
+
+    end # TestObjectAdapter
+  
+  end # Abstraction
+
+end # TDriver

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

@@ -0,0 +1,773 @@
+############################################################################
+## 
+## 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
+
+        # include abstraction module      
+        include TDriver::Abstraction::TestObjectAdapter
+        
+        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
+                  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 = "[contains(.,#{ value })]"
+                    attribute_value = "contains(.,#{ value })"
+
+                  end
+                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
+   
+          #merges elements from the nodeset, used in hybrid app situations
+          def create_merged_element(nodeset, environments, close_element=true)
+            merged_element_set = false
+
+            merged_xml = ""
+
+            nodeset.each{ | object |        
+             
+              # only one top element
+              unless merged_element_set
+
+                # retrieve object attributes
+                attributes = object.attributes
+                
+                # merge env to attributes hash
+                attributes['env'] = environments.join(';')
+                
+                # add application object xml element to new xml string
+                merged_xml << "<obj #{ hash_to_element_attributes( attributes ) }>"
+                
+                # merged element is now set, no need to do it again
+                merged_element_set = true
+                
+              end
+              
+              # append all found elements
+              object.xpath('./*').each{ | object | merged_xml << object.to_s }
+            }
+            merged_xml << "</obj>" if close_element and merged_element_set
+            merged_xml
+          end
+
+          # 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 
+            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.refresh #Refresh the test object for identification
+        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 ]
+        #  }
+        #]
+
+        source_data.attributes
+
+      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
+              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
+              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 
+          # raise MobyBase::MultipleAttributesFoundError.new( "Multiple attributes found with name '#{ 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
+        object_attributes = {}
+
+          # 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?
+
+              object_attributes[name]=value.content if inclusive_filter.include?( name.downcase )
+
+            else
+              # pass the attribute pair - no filtering done
+              if object_attributes[name]
+                object_attributes[name]="#{object_attributes[name]},#{value.content}"
+              else
+                object_attributes[name]=value.content
+              end
+            end
+
+          }
+
+        object_attributes
+
+      end
+
+      # TODO: document me
+      def self.application_layout_direction( sut )
+
+        # temporary fix until testobject will be associated to parent application object; add 'layoutDirection' to dynamic attributes filtering whitelist...
+        TDriver::AttributeFilter.add_attribute( 'layoutDirection' ){ 
+
+          # this block will be executed if attribute was not in filter list
+
+          # temporary fix: ... and refresh sut to retrieve updated xml data
+          sut.refresh
+
+        }
+              
+        # 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
+
+        # return xml root element
+        MobyUtil::XML.parse_string( "<sut name='sut' type='sut' id='#{ id }'>#{ source_data.xpath('tasInfo/obj').inject(""){ | result, element | result << element.to_s; } }</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 
+			  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
+
+          # keep error element
+          new_xml << document_root.xpath('/tasMessage/tasInfo/obj[@type="Error"]').to_s
+
+          # collect environment values
+          environments = document_root.xpath('/tasMessage/tasInfo/obj[@type="application"]/@env').collect{ | attribute | attribute.to_s }
+
+          #limit to apps
+          nodeset = document_root.xpath('/tasMessage/tasInfo/obj[@type="application"]')          
+          close_vkb = false
+          if nodeset.count > 0
+            new_xml << create_merged_element(nodeset, environments, false) 
+            close_vkb = true
+          end
+          # do the same to the vkbs
+          environments = document_root.xpath('/tasMessage/tasInfo/obj[@type="vkb_app"]/@env').collect{ | attribute | attribute.to_s }
+          nodeset = document_root.xpath('/tasMessage/tasInfo/obj[@type="vkb_app"]')
+          new_xml << create_merged_element(nodeset, environments, close_vkb)
+
+          # 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