testability-driver 1.3.0 → 1.3.1

data/ext/native_extensions.c

@@ -22,6 +22,7 @@
 #include "ruby.h"
 
 static const CCITT_16[ 256 ] = {
+
   0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
   0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
   0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
@@ -54,6 +55,7 @@ static const CCITT_16[ 256 ] = {
   0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
   0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
   0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
+
 };
 
 
@@ -96,7 +98,21 @@ static VALUE crc16_ibm( VALUE self, VALUE string ) {
 */
 
 static VALUE crc16( int argc, VALUE* argv, VALUE self ) { 
-  //klass VALUE self, VALUE string, VALUE unused_crc ) {
+
+/*
+
+  # CRC-16-CCITT    
+  def crc16( buf, crc = 0 )
+
+    # calculate the checksum
+    buf.each_byte{ | x | crc = ( ( crc << 8 ) ^ @CCITT_16[ ( crc >> 8 ) ^ x ] ) & 0xffff }
+
+    # result
+    crc
+
+  end # crc16
+
+*/
 
   // variables for arguments
   VALUE string, initial_crc;
@@ -104,29 +120,26 @@ static VALUE crc16( int argc, VALUE* argv, VALUE self ) {
   // retrieve arguments
   rb_scan_args(argc, argv, "11", &string, &initial_crc);
 
-  int crc; // = 0xffff;
-  
-  if (NIL_P(initial_crc)){
-  
-    crc = 0; 
+  // verify argument type
+  Check_Type( string, T_STRING );
+
+  // initialize crc 
+  unsigned int crc = 0; 
   
-  } else {
+  if (!NIL_P(initial_crc)){
 
     // verify initial crc value
     Check_Type( initial_crc, T_FIXNUM );
   
-    crc = NUM2INT( initial_crc );
+    crc = FIX2INT( initial_crc );
   
   }
-  
-  // verify argument type
-  Check_Type( string, T_STRING );
 
-  const char* data = RSTRING_PTR( string );
+  const unsigned char* data = RSTRING_PTR( string );
   
-  int len = RSTRING_LEN( string );
+  unsigned int len = RSTRING_LEN( string );
   
-  int c = 0;
+  unsigned char c = 0;
 
   while( len-- ){
 
@@ -142,7 +155,26 @@ static VALUE crc16( int argc, VALUE* argv, VALUE self ) {
 }
 
 static VALUE crc16_ibm( int argc, VALUE* argv, VALUE self ) { 
-  //klass VALUE self, VALUE string, VALUE unused_crc ) {
+
+/*
+
+  # IBM-CRC-16: fallback when native extensions are not supported (e.g. jruby)
+  def crc16_ibm( buf, crc = 0xffff )
+
+    buf.each_byte do | c |
+
+      crc = ( ( crc >> 4 ) & 0x0fff ) ^ @IBM_16[ ( ( crc ^ c ) & 15 ) ]
+
+      crc = ( ( crc >> 4 ) & 0x0fff ) ^ @IBM_16[ ( ( crc ^ ( c >> 4 ) ) & 15 ) ]
+
+    end
+
+    # result
+    ~crc & 0xffff
+
+  end # crc16_ibm
+
+*/
 
   // variables for arguments
   VALUE string, initial_crc;
@@ -150,29 +182,25 @@ static VALUE crc16_ibm( int argc, VALUE* argv, VALUE self ) {
   // retrieve arguments
   rb_scan_args(argc, argv, "11", &string, &initial_crc);
 
-  int crc; // = 0xffff;
-  
-  if (NIL_P(initial_crc)){
+  unsigned int crc = 0xffff; 
   
-    crc = 0xffff; 
-  
-  } else {
+  if (!NIL_P(initial_crc)){
 
     // verify initial crc value
     Check_Type( initial_crc, T_FIXNUM );
   
-    crc = NUM2INT( initial_crc );
+    crc = FIX2INT( initial_crc );
   
   }
   
   // verify argument type
   Check_Type( string, T_STRING );
 
-  const char* data = RSTRING_PTR( string );
+  const unsigned char* data = RSTRING_PTR( string );
   
-  int len = RSTRING_LEN( string );
+  unsigned int len = RSTRING_LEN( string );
   
-  int c = 0;
+  unsigned char c = 0;
 
   while( len-- ){
 

data/lib/matti.rb

@@ -17,11 +17,6 @@
 ## 
 ############################################################################
 
-=begin
-file, line = ( caller.first || "%s:%s" % [ __FILE__, __LINE__ ] ).split(":")
-$stderr.puts "%s:%s warning: require 'matti' deprecated, use require 'tdriver' instead also 'MATTI' is deprecated, use 'TDriver' instead " % [ file, line]
-=end
-
 $stderr.puts "%s:%s warning: require 'matti' deprecated, use require 'tdriver' instead. Please note that class 'MATTI' is also deprecated, use 'TDriver' instead " % ( caller.first || "%s:%s" % [ __FILE__, __LINE__ ] ).split(":")[ 0..1 ]
 
 # load matti resources and framework

data/lib/tdriver/base/behaviour/behaviours/object_behaviour_description.rb

@@ -73,7 +73,7 @@ module MobyBehaviour
 
       else
 
-        TDriver::BehaviourFactory.collect_behaviours( :index => @object_behaviours ).collect{ | behaviour | behaviour[ :name ] }.uniq.compact.sort
+        TDriver::BehaviourFactory.collect_behaviours( :index => @object_behaviours ).collect{ | behaviour | behaviour[ :name ] }.uniq.compact
 
       end
 
@@ -101,7 +101,7 @@ module MobyBehaviour
 
         ) 
 
-      }.uniq.compact.sort
+      }.uniq.compact
 
 		end
 
@@ -145,10 +145,10 @@ module MobyBehaviour
     #
     # == exceptions
     # TypeError
-    #  description: Wrong argument type %s for method name (expected Symbol or String)
+    #  description: Wrong argument type <class> for method name (expected Symbol or String)
     #
     # ArgumentError
-    #  description: Test object type of %s does not have method %s
+    #  description: Test object type of <type> does not have method <name>
     #
 		def describe_method( method_name, print = true, return_result = false )
 			

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

@@ -48,6 +48,44 @@ module TDriver
       
       end
 
+      def remove_behaviours( object )
+
+        object.check_type [ MobyBase::TestObject, MobyBase::SUT ], 'wrong argument type $1 for target object (expected $2)'
+      
+        # add behaviour information to test object
+        behaviour_index = object.instance_variable_get( :@object_behaviours )
+        
+        collect_behaviours( :index => behaviour_index ).collect{ | behaviour | 
+        
+          _module = behaviour[ :module ]
+
+          instance_methods = [ 
+            _module.instance_methods( false ), 
+            _module.private_instance_methods( false ),
+            _module.protected_instance_methods( false )  
+          ].inject([]){ | result, methods | 
+          
+            result.concat( methods )
+          
+          }
+         
+          # remove behaviour instance methods from target object       
+          instance_methods.each do | method_name | 
+          
+            object.instance_eval( "undef :#{ method_name.to_s }") # if respond_to?(:#{ method_name.to_s })" ) 
+                    
+          end
+          
+          behaviour_index.delete( behaviour[ :index ] )
+        
+        }
+
+        behaviour_index = object.instance_variable_set( :@object_behaviours, behaviour_index )
+
+        object
+      
+      end
+
       # TODO: document me
       def apply_behaviour( rule )
         
@@ -132,12 +170,63 @@ module TDriver
         rule.default = [ '*' ]
 
         # store as local variable for less AST lookups
-        _index        = rule.fetch( :index ){ [] }
+        _index        = rule.fetch( :index, [] )
         _object_type  = rule[ :object_type  ]
         _input_type   = rule[ :input_type   ]
         _env          = rule[ :env          ]
         _version      = rule[ :version      ]
 
+        _name         = rule[ :name ]
+        _any          = [ '*' ]
+
+        # collect behaviours
+        enabled_plugins.inject([]){ | result, plugin |
+
+          @behaviours_per_plugin.fetch( plugin, [] ).each do | behaviour |
+
+            # match other rules if no exact index given          
+            if _index.empty?
+
+              case _name
+              
+                when behaviour[ :name ]
+                
+                  # exact match with name
+                  result << behaviour
+                
+                when _any
+
+                  # compare rules and behaviour attributes
+                  if !( _object_type & behaviour[ :object_type ] ).empty? && 
+                    !( _input_type  & behaviour[ :input_type  ] ).empty? &&
+                    !( _env         & behaviour[ :env         ] ).empty? && 
+                    !( _version     & behaviour[ :version     ] ).empty? 
+
+                    result << behaviour 
+
+                  end
+
+              else
+                
+                false
+
+              end
+
+            else
+
+              # index given
+              result << behaviour if Array( _index ).include?( behaviour[ :index ] )
+
+            end
+            
+          end
+        
+          result
+        
+        }
+
+=begin    
+        
         @behaviours.select do | behaviour |
 
           # skip if required plugin is not registered or enabled; compare requires array and enabled_plugins array
@@ -146,14 +235,14 @@ module TDriver
           # match other rules if no exact index given          
           if _index.empty?
 
-            case rule[ :name ]
+            case _name
             
               when behaviour[ :name ]
               
                 # exact match with name
                 true
               
-              when ['*']
+              when _any
 
                 # compare rules and behaviour attributes
                 !( _object_type & behaviour[ :object_type ] ).empty? && 
@@ -175,6 +264,7 @@ module TDriver
           end
 
         end # behaviours.select
+=end
       
       end
  
@@ -243,11 +333,30 @@ module TDriver
         # behaviours container
         @behaviours = []
         
+        @behaviours_per_plugin = {}
+                
         # behaviour cache; re-collecting behaviours is not required for similar target objects
         @behaviours_cache = {}
             
       end
 
+      # TODO: document me
+      def store( behaviour_data )
+
+        behaviour_data[ :requires ].each{ | plugin |
+        
+          # retrieve array of plugin specific behaviours
+          behaviours_array = @behaviours_per_plugin[ plugin ] || []
+
+          # apply empty array unless already exist          
+          @behaviours_per_plugin[ plugin ] = behaviours_array if behaviours_array.empty?
+          
+          behaviours_array << behaviour_data
+        
+        }
+      
+      end
+
       # load and parse behaviours files
       def load_behaviours( path )
 
@@ -295,7 +404,7 @@ module TDriver
                 module_name.not_empty "behaviour #{ attributes[ "name" ].inspect } does not have module name defined or is empty", RuntimeError
 
                 # store behaviour 
-                @behaviours << {  
+                behaviour_data = {  
 
                   :index       => @behaviours.count,
     
@@ -325,6 +434,10 @@ module TDriver
                 
                 }
 
+                store behaviour_data
+
+                @behaviours << behaviour_data
+
               end # behaviour.each
 
             end # behaviours.each
@@ -334,8 +447,8 @@ module TDriver
             raise
 
           rescue MobyUtil::XML::ParseError
-          
-            raise MobyUtil::XML::ParseError, "Error while parsing behaviours file #{ behaviours[ :filename ] } due to #{ $!.message }"
+
+            raise MobyUtil::XML::ParseError, "Error while parsing behaviours file #{ filename } due to #{ $!.message }"
 
           rescue
 
@@ -346,7 +459,7 @@ module TDriver
         } # Dir.glob
       
       end # behaviours
-   
+      
     end # self
    
     # initialize behaviour factory

data/lib/tdriver/base/errors.rb

@@ -49,7 +49,7 @@ module MobyBase
 			end
 
 			error = error_type.new( message )
-			Kernel::raise error
+			raise error
 		end
 
 		# enable hooking for performance measurement & debug logging

data/lib/tdriver/base/state_object.rb

@@ -114,7 +114,8 @@ module MobyBase
 
         else
 
-          @test_object_adapter = TDriver::TestObjectAdapter
+          # Load the new xml only, so old is not supported
+          @test_object_adapter = TDriver::OptimizedXML::TestObjectAdapter
 
         end
 
@@ -176,7 +177,7 @@ module MobyBase
         end
 
         # raise exception
-        Kernel::raise MobyBase::TestObjectNotFoundError.new(
+        raise MobyBase::TestObjectNotFoundError.new(
           "The state object (#{ object_attributes.join(", ") }) has no child object with type or behaviour method with name #{ method_id.to_s.inspect }#{ search_attributes_string }" 
         )
 

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

@@ -28,7 +28,7 @@ module MobyBase
     # sut_adapter:: MobyController::SutAdapter descendant, e.g. MobyController::QT::SutAdapter
     # == raises
     # TypeError:: Wrong argument type $1 for SUT controller (expected $2)
-    # NameError:: No SUT controller found for %s (%s)
+    # NameError:: No SUT controller found for <type> (<class>)
     def initialize( sut_controllers, sut_adapter )
 
       sut_controllers.check_type String, 'Wrong argument type $1 for SUT controller (expected $2)'
@@ -123,7 +123,7 @@ module MobyBase
 
         retries += 1
 
-        if MobyBase::SUTFactory.instance.connected_suts.include?( @sut_adapter.sut_id.to_sym )
+        if TDriver::SUTFactory.connected_suts.include?( @sut_adapter.sut_id.to_sym )
 
           @sut_adapter.disconnect
 

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

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