testability-driver 1.0.3 → 1.0.4

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

@@ -125,7 +125,7 @@ module TDriver
     end
 
 		# enable hooking for performance measurement & debug logging
-		MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+		TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
   end # TestObjectCache
 

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

@@ -16,419 +16,6 @@
 ## of this file. 
 ## 
 ############################################################################
-module TDriver
-
-  class TestObjectFactory
-
-    attr_reader :test_object_adapter, :timeout, :retry_interval
-
-    # TODO: move to test object adapter
-    # TODO: This method should be in application test object
-    def get_layout_direction( sut )
-
-      sut.xml_data.at_xpath('*//object[@type="application"]/attributes/attribute[@name="layoutDirection"]/value/text()').to_s || 'LeftToRight'
-
-    end
-
-    def initialize( options )
-
-      @test_object_adapter = options[ :test_object_adapter ]
-
-      @timeout = options[ :timeout ] || MobyUtil::Parameter[ :application_synchronization_timeout, "20" ].to_i
-
-      @retry_interval = options[ :retry_interval ] || MobyUtil::Parameter[ :application_synchronization_retry_interval, "1" ].to_i
-    
-    end
-
-    # Function to set timeout for TestObjectFactory
-    # This should be used only in unit testing, otherwise should not be used
-    # sets timeout used in identifying TestObjects to new timeout
-    #
-    # == params
-    # new_timeout:: Fixnum which defines the new timeout
-    # == raises
-    # ArgumentError:: if parameter is not kind of Fixnum
-    def timeout=( value )
-
-      value.check_type( Numeric, "Wrong argument type $1 for timeout value (expected $2)" )
-
-      @timeout = value
-
-    end
-
-    def retry_interval=( value )
-
-      value.check_type( Numeric, "Wrong argument type $1 for timeout retry interval value (expected $2)" )
-
-      @retry_interval = value
-
-    end
-
-    # TODO: document me
-    def get_test_objects( rules )
-
-      # store rules hash to variable
-      object_attributes_hash = rules[ :object_attributes_hash ].clone
-
-      # remove test object identification directives for object identification attributes hash (e.g. :__index, :__multiple_objects etc.)
-      identification_directives = rules[ :identification_directives ]
-          
-      #object_attributes_hash.strip_dynamic_attributes!
-
-      # get parent object
-      parent = rules[ :parent ]
-      
-      # retrieve sut object
-      sut = parent.kind_of?( MobyBase::SUT ) ? parent : parent.sut
-
-      # create application refresh attributes hash
-      if object_attributes_hash[ :type ] == 'application'
-
-        # collect :name, :id and :applicationUid from object_attributes_hash if found
-        refresh_arguments = object_attributes_hash.collect_keys( :name, :id, :applicationUid )
-
-      else
-                          
-        if parent.kind_of?( MobyBase::TestObject )
-
-          # get current application for test object
-          refresh_arguments = { :id => parent.get_application_id }
-
-        elsif parent.kind_of?( MobyBase::SUT )
-        
-          # get current application for sut
-          refresh_arguments = { :id => sut.current_application_id }
-
-        end
-        
-      end
-            
-      # set default values 
-      identification_directives.default_values(
-      
-        # associated sut
-        :__sut => sut,
-
-        # new child objects parent object
-        :__parent => parent,
-            
-        # get timeout from rules hash or TestObjectFactory
-        :__timeout => @timeout,
-
-        # get retry interval from rules hash or TestObjectFactory
-        :__retry_interval => @retry_interval,
-
-        # determine that are we going to retrieve multiple test objects or just one
-        :__multiple_objects => false,
-
-        # determine that should all child objects childrens be retrieved
-        :__find_all_children => true,
-
-        # determine that did user give index value
-        :__index_given => identification_directives.has_key?( :__index ),
-
-        # determine index of test object to be retrieved
-        :__index => 0,
-        
-        :__refresh_arguments => refresh_arguments,
-        
-        # make search params
-        :__search_params => get_parent_params( parent ).push( make_object_search_params( object_attributes_hash ) ),
-      
-        :__xy_sorting => false,
-      
-        # test object identificator to be used
-        :__test_object_identificator => MobyBase::TestObjectIdentificator.new( object_attributes_hash )
-      
-      )
-
-      identification_directives[ :__index ].check_type( Fixnum, "Wrong value type $1 for :__index test object identification directive (expected $2)" )
-
-      # add object identification attribute keys to dynamic attributes white list
-      MobyUtil::DynamicAttributeFilter.instance.add_attributes( object_attributes_hash.keys )
-
-      child_objects = identify_object( object_attributes_hash, identification_directives, rules ).collect{ | test_object_xml |
-            
-        # create new test object
-        make_test_object( 
-        
-          # sut object to t_o
-          :sut => identification_directives[ :__sut ],      
-
-          # parent object to t_o
-          :parent => identification_directives[ :__parent ],   
-
-          # t_o xml
-          :xml_object => test_object_xml,                           
-
-          # test object factory
-          :test_object_factory => self,                                     
-
-          :object_attributes_hash => object_attributes_hash
-
-        )
-                 
-      }
-      
-      # return test object(s); either one or multiple objects
-      identification_directives[ :__multiple_objects ] ? child_objects : child_objects.first
-
-    end
-
-    # TODO: document me
-    def identify_object( object_attributes_hash, identification_directives, rules )
-      
-      MobyUtil::Retryable.until( 
-
-        # maximum time used for retrying, if timeout exceeds pass last raised exception
-        :timeout => identification_directives[ :__timeout ], 
-
-        # interval used before retrying
-        :interval => identification_directives[ :__retry_interval ],
-
-        # following exceptions are allowed; Retry until timeout exceeds or other exception type is raised
-        :exception => [ MobyBase::TestObjectNotFoundError, MobyBase::MultipleTestObjectsIdentifiedError ] 
-
-      ){
-
-        # refresh sut
-        identification_directives[ :__sut ].refresh( identification_directives[ :__refresh_arguments ], identification_directives[ :__search_params ] )
-
-        matches, rule = identification_directives[ :__test_object_identificator ].find_objects( 
-          identification_directives[ :__parent ].xml_data, 
-          identification_directives[ :__find_all_children ]
-        )
-
-        # raise exception if no matching object(s) found
-        raise MobyBase::TestObjectNotFoundError.new( 
-        
-          "Cannot find object with rule:\n%s" % rules[ :object_attributes_hash ].inspect
-
-        ) if matches.empty?
-
-        # raise exception if multiple matches found and only one expected 
-        if ( !identification_directives[ :__multiple_objects ] ) && ( matches.count > 1 && !identification_directives[ :__index_given ] )
-
-          # 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.new( 
-          
-            "Multiple test objects found with rule: %s\nMatching objects:\n%s\n" % [ 
-              rules[ :object_attributes_hash ].inspect,
-              list_matching_test_objects( matches ).each_with_index.collect{ | object, object_index | "%3s) %s" % [ object_index + 1, object ] }.join( "\n" )
-            ]
-          ) 
-            
-        end
-
-        # sort matches
-        if identification_directives[ :__xy_sorting ] == true
-                
-          # sort elements
-          identification_directives[ :__test_object_identificator ].sort_elements_by_xy_layout!( 
-
-            matches, 
-
-            get_layout_direction( identification_directives[ :__sut ] ) 
-            
-          ) 
-
-        end
-
-        # return result
-        if identification_directives[ :__multiple_objects ] && !identification_directives[ :__index_given ]
-
-          # return multiple test objects
-          matches.to_a
-
-        else
-
-          # return only one test object  
-          [ matches[ identification_directives[ :__index ] ] ]
-
-        end
-
-      }
-        
-    end
-
-    def make_test_object( rules )
-
-      # get test object factory object from hash
-      test_object_factory = rules[ :test_object_factory ]
-            
-      # get sut object from hash
-      sut = rules[ :sut ]
-      
-      # get parent object from hash
-      parent = rules[ :parent]
-      
-      xml_object = rules[ :xml_object ]
-
-      if xml_object.kind_of?( MobyUtil::XML::Element )
-
-        # retrieve test object id from xml
-        object_id = xml_object.attribute( 'id' ).to_i
-
-        # retrieve test object name from xml
-        object_name = xml_object.attribute( 'name' ).to_s
-
-        # retrieve test object type from xml
-        object_type = xml_object.attribute( 'type' ).to_s
-
-        # retrieve test object type from xml
-    	  env = ( xml_object.attribute( 'env' ) || MobyUtil::Parameter[ sut.id ][ :env ] ).to_s
-
-      else
-      
-        # defaults - refactor this
-        object_type = ""
-        
-        object_name = ""
-        
-        object_id = 0
-
-        env = MobyUtil::Parameter[ sut.id ][ :env ].to_s
-
-      end
-
-      # calculate object cache hash key
-			hash_key = ( ( ( 17 * 37 + object_id ) * 37 + object_type.hash ) * 37 + object_name.hash )
-
-      # (DO NOT!!) remove object type from object attributes hash_rule
-      #rules[ :object_attributes_hash ].delete( :type )
-
-      # get reference to parent objects child objects cache
-      parent_cache = rules[ :parent ].instance_variable_get( :@child_object_cache )
-
-      # get cached test object from parents child objects cache if found; if not found from cache pass newly created object as is
-      if parent_cache.has_object?( hash_key )
-
-        # get test object from cache
-        test_object = parent_cache[ hash_key ]
-
-        test_object.xml_data = xml_object
-
-      else
-      
-        test_object = MobyBase::TestObject.new( test_object_factory, sut, parent, xml_object )
-
-        # apply behaviours to test object
-        test_object.extend( MobyBehaviour::ObjectBehaviourComposition )
-
-        # apply behaviours to test object
-        test_object.apply_behaviour!(
-          :object_type  => [ '*', object_type ],
-          #:sut_type     => [ '*', sut.ui_type ],
-          :input_type   => [ '*', sut.input.to_s ],
-          :env          => [ '*', *env.split(";") ],	   
-          :version      => [ '*', sut.ui_version ]								   
-        )
-
-        # create child accessors
-        TDriver::TestObjectAdapter.create_child_accessors!( xml_object, test_object )
-
-        # set given parent in rules hash as parent object to new child test object    
-        test_object.instance_variable_set( :@parent, parent )
-
-        # add created test object to parents child objects cache
-        parent_cache.add_object( test_object ) 
-
-      end
-
-      # 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 ].clone )
-  
-      # do not make test object verifications if we are operating on the 
-      # base sut itself (allow run to pass)
-      unless parent.kind_of?( MobyBase::SUT )
-
-        TDriver::TestObjectVerification.verify_ui_dump( sut ) unless sut.verify_blocks.empty?
-
-      end
-
-      test_object
-
-    end
-
-    def make_object_search_params( creation_attributes )
-
-      if creation_attributes[ :type ] != 'application'
-        
-        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 )
-
-        object_search_params
-
-      else
-      
-        {}
-      
-      end    
-
-    end
-
-    def get_parent_params( test_object )
-
-      unless [ 'application', 'sut' ].include?( test_object.type ) 
-      
-        search_params.concat( get_parent_params( test_object.parent ) ) if test_object.parent         
-        search_params.concat( [ { :className => test_object.type, :tasId => test_object.id } ] ) #if test_object
-        
-        search_params
-        
-      else
-      
-        []
-      
-      end
-
-    end
-
-  private 
-
-    def list_matching_test_objects( matches )
-
-      matches.collect{ | object |
-          
-        path = [ object.attribute("type") ]
-
-        while object.attribute("type") != 'application' do
-        
-          # object/objects/object/../..
-          object = object.parent.parent
-          
-          path << object.attribute("type")
-        
-        end
-
-        path.reverse.join(".")
-      
-      }.sort
-    
-    end
-  
-  end # TestObjectFactory
-
-end # TDriver
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 module MobyBase
 
@@ -446,14 +33,13 @@ module MobyBase
     def initialize
 
       # get timeout from parameters, use default value if parameter not found
-      @timeout = MobyUtil::Parameter[ :application_synchronization_timeout, "20" ].to_i
+      @timeout = $parameters[ :application_synchronization_timeout, "20" ].to_f
 
       # get timeout retry interval from parameters, use default value if parameter not found
-      @_retry_interval = MobyUtil::Parameter[ :application_synchronization_retry_interval, "1" ].to_i
+      @_retry_interval = $parameters[ :application_synchronization_retry_interval, "1" ].to_f
 
     end
 
-    #TODO: Team TE review @ Wheels
     # Function to set timeout for TestObjectFactory
     # This should be used only in unit testing, otherwise should not be used
     # sets timeout used in identifying TestObjects to new timeout
@@ -471,63 +57,93 @@ module MobyBase
     end
 
     # TODO: document me
-    def identify_object( object_attributes_hash, identification_directives, rules )
+    def identify_object( rules )
   
+      # retrieve test object identification directives; e.g. :__index, :__xy_sorting etc 
+      directives = rules[ :identification_directives ]
+      
+      # retrieve sut object
+      sut = rules[ :parent ].instance_variable_get( :@sut )
+
+      # search parameters for find_objects feature    
+      search_parameters = make_object_search_params( rules[ :parent ], rules[ :object_attributes_hash ] )
+            
+      # default rules      
+      directives.default_values(
+      
+        # get timeout from rules hash or TestObjectFactory
+        :__timeout => @timeout,
+
+        # get retry interval from rules hash or TestObjectFactory
+        :__retry_interval => @_retry_interval,
+         
+        # determine that are we going to retrieve multiple test objects or just one
+        :__multiple_objects => false,
+
+        # determine that should all child objects childrens be retrieved
+        :__find_all_children => true,
+
+        # determine that did user give index value
+        :__index_given => directives.has_key?( :__index ),
+
+        # use sorting if index given
+        :__xy_sorting => directives.has_key?( :__index ),
+
+        # determine index of test object to be retrieved
+        :__index => 0
+                         
+      )
+
+      # identify objects until desired matches found or timeout exceeds
       MobyUtil::Retryable.until( 
 
         # maximum time used for retrying, if timeout exceeds pass last raised exception
-        :timeout => identification_directives[ :__timeout ], 
+        :timeout => directives[ :__timeout ], 
 
         # interval used before retrying
-        :interval => identification_directives[ :__retry_interval ],
+        :interval => directives[ :__retry_interval ],
 
         # following exceptions are allowed; Retry until timeout exceeds or other exception type is raised
-        :exception => [ MobyBase::TestObjectNotFoundError, MobyBase::MultipleTestObjectsIdentifiedError ] 
+        :exception => [ MobyBase::TestObjectNotFoundError, MobyBase::MultipleTestObjectsIdentifiedError ]
 
       ){
 
         # refresh sut
-        identification_directives[ :__sut ].refresh( identification_directives[ :__refresh_arguments ], identification_directives[ :__search_params ] )
-
-        matches, rule = identification_directives[ :__test_object_identificator ].find_objects( 
-          identification_directives[ :__parent ].xml_data, 
-          identification_directives[ :__find_all_children ]
-        )
+        sut.refresh( directives[ :__refresh_arguments ], search_parameters )
 
-        # raise exception if no matching object(s) found
-        raise MobyBase::TestObjectNotFoundError.new( 
+        # retrieve objects from xml
+        matches, rule = TDriver::TestObjectAdapter.get_objects(
         
-          "Cannot find object with rule:\n%s" % rules[ :object_attributes_hash ].inspect
+         rules[ :parent ].xml_data, 
+         rules[ :object_attributes_hash ], 
+         directives[ :__find_all_children ] 
 
-        ) if matches.empty?
+        )
+        
+        # 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 ( !identification_directives[ :__multiple_objects ] ) && ( matches.count > 1 && !identification_directives[ :__index_given ] )
+        if ( !directives[ :__multiple_objects ] ) && ( matches.count > 1 && !directives[ :__index_given ] )
 
           # 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.new( 
-          
-            "Multiple test objects found with rule: %s\nMatching objects:\n%s\n" % [ 
-              rules[ :object_attributes_hash ].inspect,
-              list_matching_test_objects( matches ).each_with_index.collect{ | object, object_index | "%3s) %s" % [ object_index + 1, object ] }.join( "\n" )
-            ]
-          ) 
+          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"
             
         end
 
-        # sort matches
-        if identification_directives[ :__xy_sorting ] == true
-          
+        # sort matches if enabled
+        if directives[ :__xy_sorting ] == true
+                  
           # sort elements
           TDriver::TestObjectAdapter.sort_elements( 
             matches, 
-            TDriver::TestObjectAdapter.application_layout_direction( identification_directives[ :__sut ] )
+            TDriver::TestObjectAdapter.application_layout_direction( sut )
           )
 
         end
 
-        # return result
-        if identification_directives[ :__multiple_objects ] && !identification_directives[ :__index_given ]
+        # return result; one or multiple xml elements
+        if directives[ :__multiple_objects ] && !directives[ :__index_given ]
         
           # return multiple test objects
           matches.to_a
@@ -535,7 +151,7 @@ module MobyBase
         else
 
           # return only one test object  
-          [ matches[ identification_directives[ :__index ] ] ]
+          [ matches[ directives[ :__index ] ] ]
 
         end
 
@@ -575,92 +191,107 @@ module MobyBase
         value.check_type( type, "Wrong variable type $1 for #{ key.inspect } test object identification directive (expected $2)" ) unless type.nil?
 
       }
-      
-      # get parent object
-      parent = rules[ :parent ]
-      
-      # retrieve sut object
-      sut = parent.kind_of?( MobyBase::SUT ) ? parent : parent.sut
-
-      # create application refresh attributes hash
-      if object_attributes_hash[ :type ] == 'application'
+            
+      # do not create refresh arguments hash if already exists
+      unless identification_directives.has_key?( :__refresh_arguments )
+            
+        # create application refresh attributes hash
+        if object_attributes_hash[ :type ] == 'application'
 
-        # collect :name, :id and :applicationUid from object_attributes_hash if found
-        refresh_arguments = object_attributes_hash.collect_keys( :name, :id, :applicationUid )
+          # collect :name, :id and :applicationUid from object_attributes_hash if found
+          identification_directives[ :__refresh_arguments ] = object_attributes_hash.collect_keys( :name, :id, :applicationUid )
 
-      else
-                          
-        if parent.kind_of?( MobyBase::TestObject )
+        else
+                            
+          if rules[ :parent ].kind_of?( MobyBase::TestObject )
 
-          # get current application for test object
-          refresh_arguments = { :id => parent.get_application_id }
+            # get current application for test object
+            identification_directives[ :__refresh_arguments ] = { :id => rules[ :parent ].get_application_id }
 
-        elsif parent.kind_of?( MobyBase::SUT )
-        
-          # get current application for sut
-          refresh_arguments = { :id => sut.current_application_id }
+          elsif rules[ :parent ].kind_of?( MobyBase::SUT )
+          
+            # get current application for sut
+            identification_directives[ :__refresh_arguments ] = { :id => rules[ :parent ].current_application_id }
 
+          end
+          
         end
-        
+
       end
-            
-      # set default values 
-      identification_directives.default_values(
       
-        # associated sut
-        :__sut => sut,
+      # add object identification attribute keys to dynamic attributes white list
+      MobyUtil::DynamicAttributeFilter.instance.add_attributes( object_attributes_hash.keys )
 
-        # new child objects parent object
-        :__parent => parent,
+      child_objects = identify_object( rules ).collect{ | test_object_xml |
+                
+        # 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 )
+
+          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
+
+            # retrieve test object name from xml
+            object_name = TDriver::TestObjectAdapter.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 
+              
+            # calculate object cache hash key
+            hash_key = TDriver::TestObjectAdapter.test_object_hash( object_id, object_type, object_name )
+              
+            parent_cache = sut.instance_variable_get( :@child_object_cache )                       
             
-        # get timeout from rules hash or TestObjectFactory
-        :__timeout => @timeout,
-
-        # get retry interval from rules hash or TestObjectFactory
-        :__retry_interval => @_retry_interval,
-
-        # determine that are we going to retrieve multiple test objects or just one
-        :__multiple_objects => false,
+            # get cached test object from parents child objects cache if found; if not found from cache pass newly created object as is
+            if parent_cache.has_object?( hash_key )
+
+              rules[ :parent_application ] = parent_cache[ hash_key ]
+              
+            else
+              
+              # create application test object            
+              rules[ :parent_application ] = make_test_object( 
+            
+                :parent => sut,          
+                :parent_application => nil,
+                :xml_object => application_test_object_xml
+            
+              )
+              
+            end
 
-        # determine that should all child objects childrens be retrieved
-        :__find_all_children => true,
+          else
 
-        # determine that did user give index value
-        :__index_given => identification_directives.has_key?( :__index ),
+            # could not retrieve parent application object
+            rules[ :parent_application ] = nil
+          
+          end
 
-        # determine index of test object to be retrieved
-        :__index => 0,
-        
-        :__refresh_arguments => refresh_arguments,
+          # store application test object to new test object 
+          rules[ :parent_application ].instance_variable_set( :@parent_application, rules[ :parent_application ] )
+          
+        end
         
-        # make search params
-        :__search_params => get_parent_params( parent ).push( make_object_search_params( object_attributes_hash ) ),
-      
-        # test object identificator to be used
-        :__test_object_identificator => MobyBase::TestObjectIdentificator.new( object_attributes_hash )
-      
-      )
-      
-      # add object identification attribute keys to dynamic attributes white list
-      MobyUtil::DynamicAttributeFilter.instance.add_attributes( object_attributes_hash.keys )
-
-      child_objects = identify_object( object_attributes_hash, identification_directives, rules ).collect{ | test_object_xml |
-            
         # create new test object
         make_test_object( 
         
-          # sut object to t_o
-          :sut => identification_directives[ :__sut ],      
-
-          # parent object to t_o
-          :parent => identification_directives[ :__parent ],   
+          # test objects parent test object
+          :parent => rules[ :parent ],
 
-          # t_o xml
-          :xml_object => test_object_xml,                           
+          # test objects parent application 
+          :parent_application => rules[ :parent_application ],
 
-          # test object factory
-          :test_object_factory => self,                                     
+          # xml element to test object
+          :xml_object => test_object_xml,
 
+          # object identification attributes
           :object_attributes_hash => object_attributes_hash
 
         )
@@ -672,85 +303,16 @@ module MobyBase
 
     end
 
-    def make_object_search_params( creation_attributes )
-
-      if creation_attributes[ :type ] != 'application'
-        
-        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 )
-
-        object_search_params
-
-      else
-      
-        {}
-      
-      end    
-
-    end
-
-    def get_parent_params( test_object )
-
-      unless [ 'application', 'sut' ].include?( test_object.type ) 
-
-        search_params = []
-      
-        search_params.concat( get_parent_params( test_object.parent ) ) if test_object.parent
-        search_params.concat( [ :className => test_object.type, :tasId => test_object.id ] ) #if test_object
-        
-        search_params
-        
-      else
-      
-        []
-      
-      end
-
-    end
-
-  private 
-
-    def list_matching_test_objects( matches )
-
-      matches.collect{ | object |
-          
-        path = [ object.attribute( 'type' ) ]
-
-        while object.attribute( 'type' ) != 'application' do
-        
-          # object/objects/object/../..
-          object = object.parent.parent
-          
-          path << object.attribute( 'type' )
-        
-        end
-
-        path.reverse.join( '.' )
-      
-      }.sort
-    
-    end
-
-    # TODO: parent application test object should be passed to get_test_objects
-    def get_layout_direction( sut )
-
-      sut.xml_data.at_xpath('*//object[@type="application"]/attributes/attribute[@name="layoutDirection"]/value/text()').to_s || 'LeftToRight'
-
-    end
-
+    # TODO: document me
     def make_test_object( rules )
-
-      # get test object factory object from hash
-      test_object_factory = rules[ :test_object_factory ]
-            
-      # get sut object from hash
-      sut = rules[ :sut ]
-      
+                  
       # get parent object from hash
-      parent = rules[ :parent]
+      parent = rules[ :parent ]
+
+      # retrieve sut object
+      sut = parent.instance_variable_get( :@sut )
       
+      # xml object element      
       xml_object = rules[ :xml_object ]
 
       # retrieve attributes
@@ -768,8 +330,8 @@ module MobyBase
         object_type = TDriver::TestObjectAdapter.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' ){ MobyUtil::Parameter[ sut.id ][ :env ] }.to_s
-    	  
+        env = TDriver::TestObjectAdapter.test_object_element_attribute( xml_object, 'env' ){ $parameters[ sut.id ][ :env ] }.to_s
+        
       else
       
         # defaults - refactor this
@@ -779,10 +341,10 @@ module MobyBase
         
         object_id = 0
 
-        env = MobyUtil::Parameter[ sut.id ][ :env ].to_s
+        env = $parameters[ sut.id ][ :env ].to_s
 
       end
-
+      
       # calculate object cache hash key
       hash_key = TDriver::TestObjectAdapter.test_object_hash( object_id, object_type, object_name )
       
@@ -799,28 +361,34 @@ module MobyBase
         test_object.xml_data = xml_object
 
       else
-      
+        
         # create test object
-        test_object = MobyBase::TestObject.new( test_object_factory, sut, parent, xml_object )
+        test_object = MobyBase::TestObject.new( self, sut, parent, xml_object )
 
-        # apply behaviours to test object
-        test_object.extend( MobyBehaviour::ObjectBehaviourComposition )
+        #test_object.instance_variable_set( :@object_behaviours, [] )
+
+        # apply all test object related behaviours unless object type is 'application'
+        object_type << ';*' unless object_type == 'application'
 
         # apply behaviours to test object
-        test_object.apply_behaviour!(
-          :object_type  => [ '*', object_type ],
-          #:sut_type     => [ '*', sut.ui_type ],
-          :input_type   => [ '*', sut.input.to_s ],
-          :env          => [ '*', *env.split(";") ],	   
-          :version      => [ '*', sut.ui_version ]								   
-        )
+        MobyBase::BehaviourFactory.instance.apply_behaviour!(
+
+          :object => test_object,
+          :object_type => [ *object_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 to new child 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 ] )
+
         # add created test object to parents child objects cache
         parent_cache.add_object( test_object ) 
 
@@ -845,6 +413,88 @@ module MobyBase
 
     end
 
+    # create test object search parameters for find_objects service
+    def make_object_search_params( test_object, creation_attributes )
+
+      result = get_parent_params( test_object ).push( get_object_params( creation_attributes ) )
+
+      # TODO: review find_objects controller
+      # workaround? return empty hash if no search params were 
+      result == [{}] ? {} : result
+
+    end
+
+  private 
+
+    # TODO: document me
+    def get_object_params( creation_attributes )
+
+      if creation_attributes[ :type ] != 'application'
+        
+        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 )
+
+        object_search_params
+
+      else
+      
+        {}
+      
+      end    
+    
+    end
+
+    # TODO: document me
+    def get_parent_params( test_object )
+
+      unless [ 'application', 'sut' ].include?( test_object.type ) 
+
+        search_params = []
+      
+        search_params.concat( get_parent_params( test_object.parent ) ) if test_object.parent
+        search_params.concat( [ :className => test_object.type, :tasId => test_object.id ] ) #if test_object
+        
+        search_params
+        
+      else
+      
+        []
+      
+      end
+
+    end
+
+    # TODO: document me
+    def list_matching_test_objects( matches )
+
+      matches.collect{ | object |
+          
+        path = [ object.attribute( 'type' ) ]
+
+        while object.attribute( 'type' ) != 'application' do
+        
+          # object/objects/object/../..
+          object = object.parent.parent
+          
+          path << object.attribute( 'type' )
+        
+        end
+
+        path.reverse.join( '.' )
+      
+      }.sort
+    
+    end
+
+    # TODO: document me
+    def list_matching_test_objects_as_list( matches )
+
+      list_matching_test_objects( matches ).each_with_index.collect{ | object, object_index | "%3s) %s" % [ object_index + 1, object ] }.join( "\n" )
+
+    end
+
   public # deprecated methods
 
     def set_timeout( new_timeout )
@@ -868,9 +518,8 @@ module MobyBase
     end
 
     # enable hoo./base/test_object/factory.rb:king for performance measurement & debug logging
-    MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
   end # TestObjectFactory
 
 end # MobyBase
-