testability-driver 1.1.1 → 1.2.1

data/lib/tdriver/util/common/hash.rb

@@ -22,14 +22,14 @@ class Hash
 
   def not_empty( message = "Hash must not be empty", exception = ArgumentError )
 
-    raise exception, message if empty? 
+    raise exception, message, caller if empty? 
 
     self
 
   end
 
-  # Verify that received object contains one of given keys. Raises exception is key not found.
-  def require_key( keys, message = "None of key(s) $1 found from hash" )
+  # verify that receiver object contains one of given keys. Raises exception is key not found.
+  def require_one( keys, message = "None of key(s) $1 found from hash" )
 
     # create array of types
     keys_array = Array( keys )
@@ -55,7 +55,7 @@ class Hash
       [ verbose_keys_list.join ].each_with_index{ | param, index | message.gsub!( "$#{ index + 1 }", param.to_s ) }
 
       # raise the exception
-      raise ArgumentError, message
+      raise ArgumentError, message, caller
 
     end
 
@@ -63,7 +63,18 @@ class Hash
 
   end
 
-  # Verify that received object contains all of given keys. Raises exception is key not found.
+  # verify that receiver object contains all of given keys. Raises exception is key not found.
+  def require_key( key, message = 'required key $1 not found from hash' )
+  
+    fetch( key ){
+    
+      raise ArgumentError, message.gsub!( "$1", key.inspect ), caller
+    
+    }
+  
+  end
+
+  # verify that receiver object contains all of given keys. Raises exception is key not found.
   def require_keys( keys, message = "Required key(s) $1 not found from hash" )
 
     # create array of types
@@ -87,7 +98,7 @@ class Hash
       [ verbose_keys_list.join ].each_with_index{ | param, index | message.gsub!( "$#{ index + 1 }", param.to_s ) }
 
       # raise the exception
-      raise ArgumentError, message
+      raise ArgumentError, message, caller
 
     end
 
@@ -187,6 +198,17 @@ class Hash
 
   end # strip_dynamic_attributes!
 
+  # TODO: document me
+  def to_attributes
+  
+    self.collect{ | key, value |
+
+      "#{ key.to_s }=\"#{ value.to_s.encode_to_xml }\"" 
+  
+    }.join(" ")
+  
+  end
+
   # TODO: document me
   def recursive_merge( other )
   
@@ -226,4 +248,38 @@ class Hash
   
   end # recursive_merge!
 
-end
+  # TODO: document me
+  def if_found( key )
+  
+    if has_key?( key )
+    
+      yield( key, self[ key ] )
+    
+    end
+  
+  end # if_found
+
+  # TODO: document me
+  def rename_key!( key, new )
+
+    if has_key?( key )
+    
+      self[ new ] = delete( key )
+    
+    else
+    
+      if block_given?
+      
+        yield( key, new )
+        
+      else
+        
+        raise IndexError, "key #{ key.inspect } not found", caller
+      
+      end
+          
+    end # has_key?
+  
+  end # rename_key!
+
+end # Hash

data/lib/tdriver/util/common/kernel.rb

@@ -17,9 +17,54 @@
 ## 
 ############################################################################
 
+module Kernel
+
+  # TODO: document me
+  def require_relative( file )
+
+    # require with full expanded path
+    require File.expand_path( File.join( File.dirname( caller.first.scan( /(.*?):/ ).to_s ), file ) )
+
+  end
+
+  # TODO: document me
+  def warn_caller( message, remove_eval = true )
+
+    # verify that message argument type is correct
+    raise TypeError, "wrong argument type #{ message.class } for message (expected String)" unless message.kind_of?( String )
+
+    # verify that remove_eval argument type is correct
+    raise TypeError, "wrong argument type #{ remove_eval.class } for remove evaluate calls value (expected TrueClass or FalseClass)" unless [ TrueClass, FalseClass ].include?( remove_eval.class )
+
+    # retrieve caller method, file and line number
+    begin
+
+      # remove evals if required
+      caller_stack = ( remove_eval == true ? caller.select{ | str | str !~ /^\(eval\)\:/ and str !~ /`eval'$/ } : caller )
+
+      # retrieve filename, line number and method name
+      /^(.+?):(\d+)(?::in `(.*)')?/.match( caller_stack.reverse[ -2 ].to_s )
+
+      # store matches
+      file, line, method = $1, $2, $3
+
+    rescue
+
+      # could not retrieve filename, line number and method name
+      file, line, method = [ '##', '##', 'unknown' ]
+
+    end 
+  
+    # print warning to STDOUT
+    warn message.gsub( '$1', file.to_s ).gsub( '$2', line.to_s ).gsub( '$3', method.to_s )
+
+  end
+
+end
+
 module MobyUtil
 
-  # Helper class to store verifyblock for 
+  # Helper class to store verify block for 
   # constant verifications for sut state
   class VerifyBlock 
 

data/lib/tdriver/util/common/loader.rb

@@ -26,6 +26,7 @@ require 'rbconfig'  # ??
   'numeric.rb', 
   'hash.rb', 
   'string.rb',
+  'boolean.rb',
   
   'exceptions.rb', 
   'error.rb', # TODO: move custom exceptions to exceptions.rb

data/lib/tdriver/util/common/object.rb

@@ -27,9 +27,21 @@ class Object
   
   end
 
+  def true?
+
+    false
+  
+  end
+  
+  def false?
+  
+    false
+  
+  end
+
   def not_blank( message = "Object must not be blank", exception = ArgumentError )
 
-    raise exception, message if blank? 
+    raise exception, message, caller if blank? 
 
     self
 
@@ -46,7 +58,7 @@ class Object
   def check_type( types, message = "wrong argument type $1 (expected $2)" )
 
     # raise exception if message is not type of String
-    raise TypeError, "wrong argument type #{ message.class } for message (expected String)" unless message.kind_of?( String )
+    raise TypeError, "wrong argument type #{ message.class } for message (expected String)", caller unless message.kind_of?( String )
 
     # create array of types
     type_array = Array( types )
@@ -57,7 +69,7 @@ class Object
     # collect verbose type list
     verbose_type_list = type_array.each_with_index.collect{ | type, index | 
 
-      raise TypeError, "invalid argument type #{ type } for check_type. Did you mean #{ type.class }?" unless type.kind_of?( Class )
+      raise TypeError, "invalid argument type #{ type } for check_type. Did you mean #{ type.class }?", caller unless type.kind_of?( Class )
 
       if self.kind_of?( type )
 
@@ -79,7 +91,7 @@ class Object
       [ self.class, verbose_type_list.join, self.inspect ].each_with_index{ | param, index | message.gsub!( "$#{ index + 1 }", param.to_s ) }
 
       # raise the exception
-      raise TypeError, message
+      raise TypeError, message, caller
 
     end
 
@@ -90,7 +102,7 @@ class Object
 
   def not_nil( message = "Value must not be nil", exception = ArgumentError )
 
-    raise exception, message unless self
+    raise exception, message, caller unless self
 
     self
 
@@ -99,7 +111,7 @@ class Object
   def validate( values, message = "Unexpected value $3 for $1 (expected $2)" )
 
     # raise exception if message is not type of String
-    raise TypeError, "wrong argument type #{ message.class } for message (expected String)" unless message.kind_of?( String )
+    raise TypeError, "wrong argument type #{ message.class } for message (expected String)", caller unless message.kind_of?( String )
 
     # create array of values
     values_array = Array( values )
@@ -110,7 +122,7 @@ class Object
     # collect verbose type list
     verbose_values_list = values_array.each_with_index.collect{ | value, index | 
 
-      raise TypeError.new( "Invalid argument type #{ value.class } for value (expected #{ self.class })" ) unless value.kind_of?( self.class )
+      raise TypeError, "Invalid argument type #{ value.class } for value (expected #{ self.class })", caller unless value.kind_of?( self.class )
 
       if self == value
       
@@ -132,7 +144,7 @@ class Object
       [ self.class, verbose_values_list.join, self.inspect ].each_with_index{ | param, index | message.gsub!( "$#{ index + 1 }", param.to_s ) }
 
       # raise the exception
-      raise ArgumentError, message
+      raise ArgumentError, message, caller
 
     end
 

data/lib/tdriver/util/common/string.rb

@@ -20,14 +20,33 @@
 # extend Ruby String class functionality
 class String
 
+  def true?
+
+    /^true$/i.match( self.to_s ) != nil
+  
+  end
+  
+  def false?
+  
+    /^false$/i.match( self.to_s ) != nil
+  
+  end
+
   def not_empty( message = "String must not be empty", exception = ArgumentError )
 
-    raise exception, message if empty? 
+    raise exception, message, caller if empty? 
 
     self
 
   end
 
+  # TODO: document me
+  def encode_to_xml
+
+    gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').gsub( '"', '&quot;' ).gsub( '\'', '&apos;' )
+
+  end
+
   # Function determines if string is "true" or "false"
   # == params
   # string:: String
@@ -78,7 +97,7 @@ class String
       else
       
         # raise exception if no default given
-        Kernel::raise TypeError, "Unable to convert string \"#{ self }\" to boolean (Expected \"true\" or \"false\")"
+        raise TypeError, "Unable to convert string \"#{ self }\" to boolean (Expected \"true\" or \"false\")", caller
 
       end
 

data/lib/tdriver/util/logger/logger.rb

@@ -349,7 +349,7 @@ module MobyUtil
       set_debug_exceptions # if enabled
 
       # returns logging level as string
-      logging_level = Parameter[ :logging_level, nil ]
+      logging_level = $parameters[ :logging_level, nil ]
 
       # do not enable logging if no logging level is not defined
       return nil if logging_level.nil?
@@ -384,7 +384,7 @@ module MobyUtil
               # create error dump folder if not exist, used e.g. when xml parse error
               MobyUtil::FileHelper.mkdir_path( MobyUtil::FileHelper.expand_path( $last_parameter ) )
 
-            rescue #Exception
+            rescue
 
               warn("warning: Unable to create log folder #{ $parameters[ :logging_xml_parse_error_dump_path ] } for corrupted XML UI state files")
 
@@ -403,12 +403,12 @@ module MobyUtil
 
           end
 
-        rescue ArgumentError => exception
+        rescue ArgumentError
 
           # disable xml logging
           $parameters[ :logging_xml_parse_error_dump ] = 'false'
 
-        rescue #Exception => exception
+        rescue
 
           # disable xml logging
           warn( "warning: Disabling logging due to failure (#{ $!.class }: #{ $!.message })" )

data/lib/tdriver/util/parameter/loader.rb

@@ -20,23 +20,6 @@
 # Parameter related errors
 require File.expand_path( File.join( File.dirname( __FILE__ ), 'error.rb' ) )
 
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'parameter_user_api.rb' ) )
-
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'parameter_new.rb' ) )
-
-=begin
-# Parameter hash class 
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'parameter_hash.rb' ) )
-
-# Parameter API etc
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'parameter_template.rb' ) )
-
-# Parameter API etc
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'parameter_xml.rb' ) )
-
-# Parameter end user API etc
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'parameter_user_api.rb' ) )
-
-# Parameter API etc
+# parameters related classes
 require File.expand_path( File.join( File.dirname( __FILE__ ), 'parameter.rb' ) )
-=end
+

data/lib/tdriver/util/parameter/parameter.rb

@@ -17,348 +17,1045 @@
 ##
 ############################################################################
 
-module MobyUtil
+module TDriver
 
-  class Parameter
+  class ParameterUserAPI
 
-    include Singleton
+    class << self
 
-    @@initialized = false
+      def new
+      
+        warn_caller "$1:$2 warning: #{ self.to_s } is static class; unable initialize new instance of it"
+      
+        nil
+      
+      end
 
-    private
+      # TODO: document me
+      def []=( key, value )
 
-    def initialize
+        $parameters[ key ] = value
 
-      # this can be done only once due to following method removes --tdriver_parameters argument from ARGV
-      parse_command_line_arguments
+      end
 
-      # initialize and load templates, default parameters and user defined parameter file
-      reset( true, true, true, true )
+      # TODO: document me
+      def []( *args )
 
-      # parameter singleton is now initialized
-      @@initialized = true
+        $parameters[ *args ]
 
-    end
+      end
 
-    def parse_command_line_arguments
+      # TODO: document me
+      def fetch( *args, &block )
 
-      # reset user_defined_file_defined_in_command_line_arguments flag
-      @@user_defined_parameters_file_defined_in_command_line_arguments = false
+        $parameters.fetch( *args, &block )
 
-      filename = Array.new
+      end
 
-      delete_values = Array.new
+      # TODO: document me
+      def files
 
-      # use command line argument if one exists.
-      ARGV.each_index do | index |
+        $parameters.files
 
-        if ARGV[ index ].to_s == '--matti_parameters'
-          puts "--matti_parameters is deprecated, use -tdriver_parameters instead"
-          Kernel::raise ArgumentError.new( "TDriver parameters command line argument given without a filename" ) if ARGV.count == index + 1
-          delete_values << ARGV[ index ].to_s
-        end
+      end
 
-        if ARGV[ index ].to_s == '--tdriver_parameters'
-          Kernel::raise ArgumentError.new( "TDriver parameters command line argument given without a filename" ) if ARGV.count == index + 1
-          delete_values << ARGV[ index ].to_s
-        end
+      # TODO: document me
+      def clear
 
-        if ARGV[ index ].to_s.downcase.include?('.xml')
-          # no absolute path required
-          filename << File.expand_path( ARGV[ index ].to_s )
-          #filename << MobyUtil::FileHelper.expand_path( ARGV[ index ].to_s )
-          @@user_defined_parameters_file_defined_in_command_line_arguments = true
-          delete_values << ARGV[ index ].to_s
-        end
+        $parameters.clear
+
+      end
+
+      # TODO: document me
+      def load_xml( filename )
+
+        $parameters.parse_file( filename )
+
+      end
+
+      # TODO: document me
+      def reset( *keys )
+
+        $parameters.reset
 
       end
 
-      #clean up ARGV
-      delete_values.each do | value |
-        indx = ARGV.index( value )
-        ARGV.delete_at( indx )
+      # TODO: document me
+      def inspect
+
+        $parameters.inspect
+
       end
 
-      if filename
+      # TODO: document me
+      def to_s
+
+        $parameters.to_s
+
+      end
+
+      # TODO: document me
+      def keys
+
+        $parameters.keys
+
+      end
+
+      # TODO: document me
+      def values
+
+        $parameters.values
+
+      end
+
+      # TODO: document me
+      def configured_suts
+      
+        $parameters.configured_suts
+      
+      end
+
+    end # self
+
+    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+
+  end # ParameterUserAPI
+
+  class ParameterHash < Hash
+
+    # TODO: document me
+    def []( key, *default, &block )
+
+      $last_parameter = fetch( key ){ 
+
+        if default.empty?
+
+          raise MobyUtil::ParameterNotFoundError, "Parameter #{ key } not found" unless block_given?
 
-        filename.each do | parameter_file |
+          # yield with key if block given
+          yield key
+
+        else
+        
+          raise ArgumentError, "Only one default value allowed for parameter (#{ default.join(', ') })" unless default.size == 1
+          
+          #result = default.first
+          
+          #result.kind_of?( Hash ) ? convert_hash( result ) : result
+          
+          convert_hash( default.first )
           
-          raise MobyUtil::FileNotFoundError, "User defined TDriver parameters file #{ parameter_file } does not exist" unless File.exist?( parameter_file )
           
         end
+
+      }
+
+    end
+
+    # TODO: document me
+    def []=( key, value )
+
+      raise MobyUtil::ParameterNotFoundError, 'Parameter key nil is not valid' unless key
+
+      super key, convert_hash( value ) # value.kind_of?( Hash ) ? convert_hash( value ) : value
+
+    end
+    
+    # for backwards compatibility
+    def kind_of?( klass )
+    
+      if klass == MobyUtil::ParameterHash
+      
+        warn_caller '$1:$2 warning: deprecated class MobyUtil::ParameterHash, use TDriver::ParameterHash instead'
+      
+        true
+      
+      else
         
+        super klass
+      
       end
+        
+    end
+    
+  private
 
-      @@filename_from_command_list_arguments = filename
+    # TODO: document me
+    def convert_hash( value )
+    
+      value.kind_of?( Hash ) ? ParameterHash[ value.collect{ | key, value | [ key, value.kind_of?( Hash ) ? convert_hash( value ) : value ] } ] : value
 
-      filename
+      #value.class == Hash ? ParameterHash[ value.collect{ | key, value | [ key, value.class == Hash ? convert_hash( value ) : value ] } ] : value
 
     end
+    
+    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+
+  end # ParameterHash
 
-  protected
+  class Parameter
+  
+    # singleton and private methods
+    class << self
 
-    def reset_flags
+      def new
+      
+        warn_caller "$1:$2 warning: #{ self.to_s } is static class; unable initialize new instance of it"
+      
+        nil
+      
+      end
+      
+      # TODO: document me
+      def init
 
-      # reset loaded_parameter_files list
-      @@loaded_parameter_files = []
+        # initialize only once 
+        return if defined?( @initalized )
 
-      # reset templates_loaded flag
-      @@templates_loaded = false
+        # retrieve platform name
+        @platform = MobyUtil::EnvironmentHelper.platform
 
-      # reset default_parameters_loaded flag
-      @@default_parameters_loaded = false
+        # detect is posix platform
+        @is_posix = MobyUtil::EnvironmentHelper.posix?
 
-    end
+        # retrieve parameter filenames from command line arguments
+        parse_command_line_arguments
+
+        # reset templates and parameters
+        reset_hashes
+      
+        # indicates that class is already initialized - templates and parameters will not reset
+        @initialized = true
+
+      end
+    
+      private
+
+      def parse_command_line_arguments
+
+        # reset command line argument files list
+        @command_line_argument_files = [] 
+
+        capture_elements = false
+
+        ARGV.each_with_index do | value, index |
+        
+          value = value.to_s
+        
+          case value
+          
+            when '--tdriver_parameters', '--matti_parameters'
+
+              warn "warning: #{ value } is deprecated, use -tdriver_parameters instead" if value == '--matti_parameters' 
+            
+              # capture following xml filenames
+              capture_elements = true
+
+              # mark element to be removed
+              ARGV[ index ] = nil
+            
+          else
+
+            # process the string if capturing arguments
+            if capture_elements
+
+              # stop capturing if is a option (e.g. --version)
+              if [ '-' ].include?( value[ 0 ].chr ) 
+
+                capture_elements = false
+              
+              # add argument to parameters list if meets the regexp and capture_element is true
+              elsif /\.xml$/i.match( value )
+             
+                # expand filename
+                value = File.expand_path( value )
+              
+                # raise exception if given file does not found
+                raise MobyUtil::FileNotFoundError, "User defined TDriver parameters file #{ value } does not exist" unless File.exist?( value )
+
+                # add file to command line arguments files
+                @command_line_argument_files << value
+
+                # mark element to be removed
+                ARGV[ index ] = nil
+              
+              end # if
+
+            end # else
+          
+          end # case
+        
+        end # each_with_index
 
-    def reset( load_template_files = true, load_parameter_defaults = true, load_default_parameters = true, load_command_line_parameters = true )
+        # raise exception if "--tdriver_parameters" option found but no filenames defined 
+        if capture_elements && @command_line_argument_files.empty? 
+        
+          raise ArgumentError, 'TDriver parameters command line argument given without a filename'
+        
+        end
+        
+        # remove nil elements from array
+        ARGV.compact!
+        
+        # return collected filenames
+        @command_line_argument_files
+      
+      end
 
-      reset_flags
+      # TODO: document me
+      def initialize_class
+      
+        # initialize only once
+        return if defined?( @parameters )
+      
+        # class variables not used; read below article: 
+        # http://www.oreillynet.com/ruby/blog/2007/01/nubygems_dont_use_class_variab_1.html
+      
+        # parameters container
+        @parameters = ParameterHash.new
 
-      # load parameter templates
-      load_templates if load_template_files
+        # templates container
+        @templates = ParameterHash.new
 
-      # load global parameters (root level, e.g. MobyUtil::Parameter[ :logging_outputter_enabled ])
-      @@parameters = MobyUtil::ParameterTemplates.instance.get_template_from_xml( 'global' )
+        # platform enum 
+        @platform = nil
+        
+        # determine if platform is type of posix
+        @is_posix = nil
+        
+        # list of loaded SUT's
+        @sut_list = []
+
+        # list of loaded parameter filenames
+        @parameter_files = []
+
+        # list of loaded template filenames
+        @template_files = []
+        
+        # files defined in command line arguments
+        @command_line_argument_files = [] 
+
+        # templates cache
+        @cache = {}
 
-      # load and merge with default parameters
-      @@parameters.merge_with_hash!( load_default_parameter_files ) if load_parameter_defaults
+      end
 
-      # use filename from command line argument if one exists otherwise use default.
-      filename = load_command_line_parameters ? @@filename_from_command_list_arguments : nil
+      # TODO: document me
+      def load_default_parameters
+      
+        # collect all templates
+        Dir.glob( MobyUtil::FileHelper.expand_path( 'defaults/*.xml' ) ).each { | filename | 
 
-      # load default tdriver/tdriver_parameters.xml file
-      load_parameters_xml( "tdriver_parameters.xml" ) if load_default_parameters
+          file_content = load_file( filename )
+          
+          MobyUtil::XML.parse_string( file_content ).xpath( '*' ).each{ | element |
+
+            # merge new hash to parameters hash
+            @parameters.recursive_merge!( 
+            
+              # parse element and convert it to hash 
+              process_element( element )
+              
+            )
+            
+          }
+          
+          # add file to loaded parameter files list
+          @parameter_files << filename
 
-      # load parameters files unless file does not exist
-      if filename
+        }
       
-        filename.each do | parameter_file |
+      end
+
+      # TODO: document me
+      def load_file( filename )
 
-          load_parameters_xml( parameter_file ) #if File.exist?( parameter_file )
+        filename = MobyUtil::FileHelper.expand_path( filename )
+
+        begin
+
+          MobyUtil::FileHelper.get_file( filename )
+
+        rescue MobyUtil::EmptyFilenameError
+
+          raise $!, 'Unable to load parameters XML file due to filename is empty or nil'
+
+        rescue MobyUtil::FileNotFoundError
+
+          raise
+
+        rescue IOError
+
+          raise $!, "Error occured while loading xml file. Reason: #{ $!.message }"
+
+        rescue
+
+          raise MobyUtil::ParameterFileParseError, "Error occured while parsing parameters xml file #{ filename }\nDescription: #{ $!.message }"
 
         end
+
+      end
+      
+      # TODO: document me
+      def process_element( xml )
+                
+        # calculate xml hash
+        xml_hash = xml.to_s.hash
         
+        return @cache[ xml_hash ] if @cache.has_key?( xml_hash )
+
+        # default results 
+        results = ParameterHash.new
+
+        # go through each element in xml
+        xml.xpath( "*" ).each{ | element |
+
+          # retrieve element attributes as hash
+          attributes = element.attributes
+
+          # default value
+          value = attributes[ 'value' ]
+
+          # generic posix value - overwrites attribute["value"] if found
+          value = attributes[ 'posix' ] unless attributes[ 'posix' ].nil? if @is_posix
+
+          # platform specific value - overwrites existing value
+          value = attributes[ @platform.to_s ] unless attributes[ @platform.to_s ].nil?
+
+          # retrieve name attribute
+          name = attributes[ 'name' ]
+
+          case element.name
+
+            when 'keymap'
+
+              # use element name as parameter name ("keymap")
+              name = element.name
+
+              # read xml file from given location if defined - otherwise pass content as is
+              if attributes[ 'xml_file' ]
+
+                # merge hash values (value type of hash)
+                value = process_file( attributes[ 'xml_file' ] )
+
+              else
+
+                # use element content as value
+                value = process_element( element )
+
+              end
+
+              # retrieve environment attribute from xml
+              env = attributes[ 'env' ].to_s
+
+              # set environment to 'default' unless defined in xml element
+              env = 'default' if env.empty?
+
+              # store keymap as hash
+              value = { env.to_sym => value, :all => value, :default_keymap => env.to_sym }
+              
+            when 'fixture'
+
+              name.not_blank( "No name defined for fixture \"#{ element.to_s }\"", SyntaxError )
+
+               value = { 
+               
+                 :plugin => attributes[ 'plugin' ].not_blank( "No name defined for fixture with value #{ name }", SyntaxError ),
+                  
+                 :env => attributes[ 'env' ]
+                 
+               }
+               
+            when 'parameter'
+
+              # verify that name attribute is defined
+              name.not_blank( "No name defined for parameter with value #{ value }", SyntaxError )
+
+              # return value as is
+              #value.not_nil( "No value defined for parameter with name #{ name }", SyntaxError )
+
+              value = '' if value.nil?
+
+            when 'method'
+
+              # verify that name attribute is defined
+              name.not_blank( "No name defined for parameter with value #{ value }", SyntaxError )
+
+              # return value as is
+              #value.not_nil( "No value defined for parameter with name #{ name }", SyntaxError )
+
+              value = attributes[ 'args' ]
+
+            when 'sut'
+
+              # use id as parameter name
+              name = attributes[ 'id' ]
+
+              # verify that name attribute is defined
+              name.not_blank( "No name defined for SUT \"#{ element.to_s }\"", SyntaxError )
+            
+              # add SUT to found sut list
+              @sut_list << name unless @sut_list.include?( name ) 
+   
+              # retrieve names of used templates 
+              templates = attributes[ 'template' ]
+
+              # empty value by default
+              value = ParameterHash.new
+
+              unless templates.blank?
+
+                # retrieve each defined template
+                templates.split( ';' ).each{ | template |
+                
+                  # merge template with current value hash
+                  value.recursive_merge!( 
+        
+                    # retrieve template          
+                    get_template( template )
+                  
+                  )
+                
+                }
+
+              end
+
+              # merge sut content with template values
+              value.recursive_merge!( process_element( element ) )
+
+          else
+
+            # use element name as parameter name (e.g. fixture, keymap etc)
+            name = element.name
+
+            # read xml file from given location if defined - otherwise pass content as is
+            if attributes[ 'xml_file' ]
+
+              # merge hash values (value type of hash)
+              value = process_file( attributes[ 'xml_file' ] )
+
+            else
+
+              # use element content as value
+              value = process_element( element )
+
+            end
+            
+          end
+
+          # store values to parameters
+          results[ name.to_sym ] = value
+
+        }
+
+        # store to cache and return hash as result
+        @cache[ xml_hash ] = results
+
+      end
+      
+      # TODO: document me
+      def parse_template( name )
+      
+        template = @templates[ name ]
+        
+        unless template.kind_of?( Hash )
+        
+          result = ParameterHash.new
+          
+          # retrieve each inherited template
+          template[ 'inherits' ].to_s.split(";").each{ | inherited_template |
+                
+            result.recursive_merge!( 
+            
+              parse_template( inherited_template )
+            
+            )
+          
+          }
+          
+          # merge template content with inherited templates and store to templates hash table 
+          @templates[ name ] = result.recursive_merge!( 
+          
+            process_element( template ) 
+          
+          )
+   
+        else
+        
+          # template is already parsed, pass template hash as is 
+          template
+                
+        end
+      
       end
 
+      # TODO: document me
+      def load_templates
 
-    end
+        # collect all templates
+        Dir.glob( MobyUtil::FileHelper.expand_path( 'templates/*.xml' ) ).each { | filename | 
 
-    def load_templates
+          unless @template_files.include?( filename )
 
-      @@templates_loaded = true
+            # read file content
+            file_content = load_file( filename )
 
-      MobyUtil::ParameterTemplates.instance.load_templates()
+            MobyUtil::XML.parse_string( file_content ).root.xpath( 'template' ).each{ | template |
 
-    end
+              # store template element to hash
+              @templates[ template[ 'name' ] ] = template
+              
+            }
 
-    def load_default_parameter_files
+            # add file to loaded templates files list
+            @template_files << filename
 
-      @@default_parameters_loaded = true
+          end
 
-      # load default parameter values
-      MobyUtil::ParameterXml.parse(
+        }
+        
+        # parse templates hash; convert elements to hash
+        @templates.each_pair{ | name, template | 
+        
+          # convert element to hash
+          parse_template( name )
+        
+        }
+      
+      end
 
-        MobyUtil::ParameterXml.merge_files( 'defaults/', 'parameters', '/parameters/*' ){  | filename |
+      # TODO: document me
+      def get_template( name )
+      
+        @templates.fetch( name ){ 
 
-          @@loaded_parameter_files << filename unless @@loaded_parameter_files.include?( filename )
+          # return empty hash if template not found
+          ParameterHash.new
 
         }
+      
+      end
 
-      )
+      # TODO: document me
+      def reset_hashes( options = {} )
+        
+        # default options
+        options.default_values( 
+        
+          :reset_templates => true,
+          :reset_parameters => true,
+          
+          :load_default_parameters => true,
+          :load_user_parameters => true,
+          :load_command_line_parameters => true
+        
+        )
+        
+        # empty parameters hash        
+        if options[ :reset_parameters ] == true
 
-    end
+          @parameter_files.clear
 
-  public
+          @parameters.clear 
 
-    # reset parameters class
-    def reset_parameters
+        end
 
-      MobyUtil::ParameterXml.reset
+        if options[ :reset_templates ] == true
+        
+          @template_files.clear
+        
+          # empty templates hash        
+          @templates.clear
 
-      reset( true, true, true, true )
+          # load parameter templates
+          load_templates
 
-    end
+        end
 
-    # load additional parameter xml files
-    def load_parameters_xml( filename, reset = false )
+        # apply global parameters to root level (e.g. MobyUtil::Parameter[ :logging_outputter_enabled ])
+        @parameters.recursive_merge!( get_template( 'global' ) )
 
-      reset_parameters if reset == true
+        # load and apply default parameter values
+        load_default_parameters if options[ :load_default_parameters ] == true
 
-      filename = MobyUtil::FileHelper.expand_path( filename )
+        # load main parameter configuraion file
+        load_parameters_file( 'tdriver_parameters.xml' ) if options[ :load_user_parameters ] == true
 
-      Kernel::raise MobyUtil::FileNotFoundError.new( "Parameters file %s does not exist" % [ filename ] ) if !File.exist?( filename )
+        if options[ :load_command_line_parameters ] == true
 
-      @@parameters.merge_with_hash!(
+          @command_line_argument_files.each{ | filename |
+          
+            load_parameters_file( filename )
+          
+          }
 
-        MobyUtil::ParameterXml.parse_file( filename )
+        end
 
-      )
+      end
 
-      @@loaded_parameter_files << filename
+      # TODO: document me
+      def process_file( filename )
 
-    end
- 
-    # empty parameters hash
-    def clear
+        begin
+        
+          # load content from file
+          file_content = load_file( filename )
+        
+          # parse file content and retrieve root element
+          root_element = MobyUtil::XML.parse_string( file_content ).root
+        
+          # parse root element
+          process_element( root_element )
 
-      MobyUtil::ParameterXml.reset
+        rescue MobyUtil::FileNotFoundError
 
-      reset_flags
+          raise $!, "Parameters file #{ MobyUtil::FileHelper.expand_path( filename ) } does not exist"
 
-      @@parameters.clear
+        rescue
 
-    end
+          raise MobyUtil::ParameterFileParseError, "Error occured while parsing parameters XML file #{ filename }. Reason: #{ $!.message } (#{ $!.class })"
+
+        end
+
+      end
+      
+      def process_string( source )
+
+        begin
+                
+          # parse file content and retrieve root element
+          root_element = MobyUtil::XML.parse_string( source ).root
+
+          # parse root element
+          process_element( root_element )
+
+        rescue
+
+          raise MobyUtil::ParameterXmlParseError, "Error occured while parsing parameters XML string. Reason: #{ $!.message } (#{ $!.class })"
+
+        end
+      
+      end
+      
+      def load_parameters_file( filename )
 
-  public # singleton methods
+        filename = MobyUtil::FileHelper.expand_path( filename )
+  
+        unless @parameter_files.include?( filename )
 
+          begin
+
+            @parameters.recursive_merge!(
+
+              process_file( filename )
+
+            )
+
+          rescue MobyUtil::FileNotFoundError
+
+            raise $!, "Parameters file #{ filename } does not exist"
+          
+          end
+
+          # add file to loaded parameter files list
+          @parameter_files << filename
+
+        end # unless
+      
+      end # def
+      
+    end # self
+    
     # TODO: document me
-    def self.parse_file( *args )
+    def self.parse_file( filename, reset_parameters = false )
+
+      # check argument type for filename
+      filename.check_type [ String ], 'wrong argument type $1 for filename argument (expected $2)'
+
+      # check argument type for filename
+      reset_parameters.check_type [ TrueClass, FalseClass ], 'wrong argument type $1 for reset_parameters boolean argument (expected $2)'
+
+      # reset parameter hash if requested
+      @parameters.clear if reset_parameters == true
     
-      self.instance.load_parameters_xml( *args )
+      # load and parse given file
+      load_parameters_file( filename )
     
     end
-
+    
     # TODO: document me
     def self.parse_string( source, merge_hashes = true )
-
-      self.instance unless @@initialized
     
-      if merge_hashes
+      # check argument type for source
+      source.check_type [ String ], 'wrong argument type $1 for source XML argument (expected $2)'
 
-        @@parameters.merge_with_hash!(
+      # check argument type for merge_hashes
+      merge_hashes.check_type [ TrueClass, FalseClass ], 'wrong argument type $1 for merge_hashes argument (expected $2)'
 
-          MobyUtil::ParameterXml.parse( source )
+      # process xml string, returns hash as result
+      hash = process_string( source )  
 
-        )
+      if merge_hashes
+      
+        @parameters.recursive_merge!( hash )
       
       else
 
-        @@parameters.merge!(
-
-          MobyUtil::ParameterXml.parse( source )
-
-        )
+        @parameters.merge!( hash )
       
       end
     
     end
-
+        
     # TODO: document me
     def self.clear
     
-      self.instance.clear
+      @parameter_files.clear
     
-    end
+      @parameters.clear
     
+    end
+
     # TODO: document me
-    def self.reset
+    def self.files
     
-      self.instance.reset_parameters
+      # return loaded parameter files list
+      @parameter_files
     
     end
 
-    # Function for returning the value of a parameter. If the parameters is not yet populated it populates
-    # it with default file (tdriver_home/tdriver_parameters.xml)
-    # == params
-    # key:: Symbol containing the name of the parameter to be returned
-    # == returns
-    # String:: value of the parameter, or nil if not found
-    def self.[]( key, *default )
-
-      self.instance unless @@initialized
-
-      @@parameters[ key, *default ]
+    # TODO: document me
+    def self.template_files
+    
+      # return loaded parameter files list
+      @template_files
+    
+    end
 
+    # TODO: document me
+    def self.has_key?( key )
+    
+      @parameters.has_key?( key )
+    
     end
 
-    def self.fetch( key, *default, &block )
+    # TODO: document me
+    def self.has_value?( key )
+    
+      @parameters.has_value?( key )
+    
+    end
 
-      self.instance unless @@initialized
+    # TODO: document me
+    def self.keys
+    
+      @parameters.keys
+    
+    end
 
-      @@parameters.method(:[]).call( key, *default, &block )
+    # TODO: document me
+    def self.values
+    
+      @parameters.values
+    
+    end
 
+    # TODO: document me
+    def self.[]( key, *default )
+    
+      @parameters[ key, *default ]
+          
     end
 
-    def self.delete( key )
+    # TODO: document me
+    def self.[]=( key, value )
     
-      @@parameters.delete( key )
+      @parameters[ key ] = value
     
     end
 
-    # Function for setting the value of a parameter. If the parameters is not yet populated it populates
-    # it with default file (tdriver_home/tdriver_parameters.xml)
-    # == params
-    # key:: Symbol containing the name of the parameter to be modified
-    # == returns
-    # String:: new value of the parameter, or nil if not found
-    def self.[]=( key, value )
+    # TODO: document me
+    def self.fetch( key, *default, &block )
 
-      self.instance unless @@initialized
+      @parameters.__send__( :[], key, *default, &block )
 
-      Kernel::raise ParameterNotFoundError.new( "Unable to set parameter value due to nil is not valid key; Parameter key must be type of String or Symbol" ) unless key
+    end
+
+    # TODO: document me
+    def self.if_found( key, &block )
 
-      @@parameters[ key ] = value
+      @parameters.__send__( :if_found, key, &block )
 
     end
 
+    # TODO: document me
+    def self.delete( key )
+    
+      @parameters.delete( key )
+    
+    end
+    
+    # TODO: document me
     def self.inspect
+    
+      @parameters.inspect
+    
+    end
 
-      self.instance unless @@initialized
+    # TODO: document me
+    def self.templates
+    
+      @templates
+    
+    end
 
-      @@parameters.inspect
+    def self.parameters
 
+      warn "warning: deprecated method #{ self.name }##{ __method__ }; please use #{ self.name }#hash instead"
+    
+      hash
+      
     end
 
-    def self.to_s
+    def self.hash
+    
+      @parameters
+      
+    end
 
-      self.instance unless @@initialized
+    # TODO: document me
+    def self.reset
 
-      @@parameters.to_s
+      reset_hashes
+          
+    end
 
+    # TODO: document me
+    def self.configured_suts
+    
+      @sut_list
+    
+    end
+  
+    # deprecated methods
+    def self.reset_parameters
+    
+      warn "warning: deprecated method #{ self.name }##{ __method__ }; please use #{ self.name }#reset instead"
+    
+      reset
+    
     end
 
-    def self.parameters
+    # load parameter xml files
+    def self.load_parameters_xml( filename, reset = false )
 
-      self.instance unless @@initialized
+      warn "warning: deprecated method #{ self.name }##{ __method__ }; please use #{ self.name }#parse_file instead"
 
-      @@parameters
+      parse_file( filename, reset )
 
     end
+  
+    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
-    def self.keys
+    # initialize parameters class
+    initialize_class
 
-      @@initialized ? @@parameters.keys : []
+  end # Parameter
 
-    end
+end
 
-    def self.values
+module MobyUtil
 
-      @@initialized ? @@parameters.values : []
+  class ParameterHash
 
-    end
+    class << self
+            
+      def new
+      
+        warn_caller "$1:$2 warning: #{ self.to_s } is deprecated; use TDriver::ParameterHash instead"
+      
+        TDriver::ParameterHash.new
+      
+      end
 
-    def self.configured_suts
+    end # self
+  
+  end # ParameterHash
 
-      self.instance unless @@initialized
+  class Parameter
+  
+    class << self
+
+      undef :inspect
+            
+      def new
+      
+        warn_caller "$1:$2 warning: #{ self.to_s } is static class; unable initialize new instance of it"
+      
+        nil
+      
+      end
+        
+      def method_missing( id, *args )
+          
+        warn_caller "$1:$2 warning: deprecated method; use TDriver::Parameter##{ id.to_s } instead of MobyUtil::Parameter##{ id.to_s }"
+      
+        TDriver::Parameter.__send__( id, *args ) 
+            
+      end
 
-      MobyUtil::ParameterXml.sut_list
+      # TODO: document me
+      def instance
+      
+        warn_caller "$1:$2 warning: deprecated method #{ self.name }##{ __method__ }; please use #{ self.name } class static methods instead"
+        
+        TDriver::Parameter
+      
+      end
+    
+    end # self
+  
+  end # Parameter
+  
+  class ParameterUserAPI
+  
+    class << self
 
-    end
+      undef :inspect
 
-    def self.files
+      def new
+      
+        warn_caller "$1:$2 warning: #{ self.to_s } is static class; unable initialize new instance of it"
+      
+        nil
+      
+      end
+    
+      def method_missing( id, *args )
+              
+        warn_caller "$1:$2 warning: deprecated method; use TDriver::ParameterUserAPI##{ id.to_s } instead of MobyUtil::ParameterUserAPI##{ id.to_s }"
+      
+        TDriver::ParameterUserAPI.__send__( id, *args )
+            
+      end
 
-      @@loaded_parameter_files
+      # TODO: document me
+      def instance
 
-    end
+        warn_caller "$1:$2 warning: deprecated method #{ self.name }##{ __method__ }; please use #{ self.name } class static methods instead"
 
-    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+        TDriver::ParameterUserAPI
 
-  end # Parameter
+      end
+    
+    end # self
+  
+  end # ParameterUserAPI
 
 end # MobyUtil
 
 # set global variable pointing to parameter class
-$parameters = MobyUtil::Parameter
+$parameters = TDriver::Parameter #MobyUtil::Parameter
 
 # set global variable pointing to parameter API class
-$parameters_api = MobyUtil::ParameterUserAPI
+$parameters_api = TDriver::ParameterUserAPI