testability-driver 1.0.4 → 1.1.0

data/lib/tdriver/tdriver.rb

@@ -57,7 +57,7 @@ module TDriver
 	# ArgumentError:: SUT type not defined
 	# ArgumentError:: SUT type '%s' not supported
 	# ArgumentError:: Sut id not given
-	# MobyUtil::ParameterFileNotFoundError:: if paramter file 'tdriver_home'/tdriver_parameters.xml is not found
+	# MobyUtil::ParameterFileNotFoundError:: if paramter file (tdriver_parameters.xml in TDriver home directory) is not found
 	# === returns
 	# Object:: Object that SutFactory returns 
 	# === example
@@ -115,10 +115,18 @@ module TDriver
 	end
 
 	# Wrapper for MobyUtil::ParameterUserAPI class with methods e.g. [] and []=, files and load_xml etc.
-	def self.parameter
+	def self.parameter( *arguments )
 
-    $parameters_api
+    if arguments.count == 0
     
+      $parameters_api
+          
+    else
+    
+      $parameters_api[ *arguments ]
+    
+    end
+
 	end
 
 	# Wrapper for MobyUtil::Logger class
@@ -133,6 +141,9 @@ module TDriver
 
 end # TDriver
 
+# initialize parameters
+$parameters.init
+
 # enable logging engine
 $logger.enable_logging
 

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

@@ -0,0 +1,53 @@
+############################################################################
+##
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+## All rights reserved.
+## Contact: Nokia Corporation (testabilitydriver@nokia.com)
+##
+## This file is part of Testability Driver.
+##
+## If you have questions regarding the use of this file, please contact
+## Nokia at testabilitydriver@nokia.com .
+##
+## This library is free software; you can redistribute it and/or
+## modify it under the terms of the GNU Lesser General Public
+## License version 2.1 as published by the Free Software Foundation
+## and appearing in the file LICENSE.LGPL included in the packaging
+## of this file.
+##
+############################################################################
+
+class Exception
+
+  # TODO: document me
+  def nested_backtrace
+
+    if backtrace
+
+      _backtrace = backtrace.dup
+      
+      begin
+
+        _backtrace[ 0 ] = "#{ _backtrace.first.to_s } raised #{ self.class.name }: #{ message.to_s }"
+
+        _backtrace.unshift( caller.first )
+
+      rescue
+      
+        # exception raised, do not alter backtrace
+
+      end
+
+    else
+    
+      # no backtrace available
+      _backtrace = []
+    
+    end
+
+    # return backtrace array
+    _backtrace
+
+  end
+
+end # Exception

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

@@ -22,7 +22,9 @@ class Hash
 
   def not_empty( message = "Hash must not be empty", exception = ArgumentError )
 
-    raise exception.new( message ) if self.empty? 
+    raise exception, message if empty? 
+
+    self
 
   end
 
@@ -30,27 +32,30 @@ class Hash
   def require_key( keys, message = "None of key(s) $1 found from hash" )
 
     # create array of types
-    keys_array = keys.kind_of?( Array ) ? keys : [ keys ]    
+    keys_array = Array( keys )
 
     found = false
 
     verbose_keys_list = keys_array.each_with_index.collect{ | key, index | 
 
-      found = true if self.has_key?( key )
+      if has_key?( key )
+        found = true
+        break 
+      end
 
       # result string, separate types if multiple types given
       "#{ ( ( index > 0 ) ? ( index + 1 < keys_array.count ? ", " : " or " ) : "" ) }#{ key.inspect }"
           
-    }.join
+    }
 
     # raise exception if type did not match
     unless found
 
       # convert macros
-      [ verbose_keys_list ].each_with_index{ | param, index | message.gsub!( "$#{ index + 1 }", param.to_s ) }
+      [ verbose_keys_list.join ].each_with_index{ | param, index | message.gsub!( "$#{ index + 1 }", param.to_s ) }
 
       # raise the exception
-      raise ArgumentError.new( message )
+      raise ArgumentError, message
 
     end
 
@@ -62,27 +67,27 @@ class Hash
   def require_keys( keys, message = "Required key(s) $1 not found from hash" )
 
     # create array of types
-    keys_array = keys.kind_of?( Array ) ? keys : [ keys ]    
+    keys_array = Array( keys )
 
     found = true
 
     verbose_keys_list = keys_array.each_with_index.collect{ | key, index | 
 
-      found = false unless self.has_key?( key )
+      found = false unless has_key?( key )
 
       # result string, separate types if multiple types given
       "#{ ( ( index > 0 ) ? ( index + 1 < keys_array.count ? ", " : " and " ) : "" ) }#{ key.inspect }"
           
-    }.join
+    }
 
     # raise exception if type did not match
     unless found
 
       # convert macros
-      [ verbose_keys_list ].each_with_index{ | param, index | message.gsub!( "$#{ index + 1 }", param.to_s ) }
+      [ verbose_keys_list.join ].each_with_index{ | param, index | message.gsub!( "$#{ index + 1 }", param.to_s ) }
 
       # raise the exception
-      raise ArgumentError.new( message )
+      raise ArgumentError, message
 
     end
 
@@ -93,16 +98,20 @@ class Hash
   # collect given keypairs from hash 
   def collect_keys( *keys )
   
-    Hash[ self.select{ | key, value | true if keys.include?( key ) } ]
+    #Hash[ self.select{ | key, value | true if keys.include?( key ) } ]
   
+    # optimized version, approx 47.9% faster
+    keys.inject( {} ){ | hash, key | hash[ key ] = self[ key ] if has_key?( key ); hash }
+    
   end
 
   # remove keys from hash, return hash of deleted keys as result
   def delete_keys!( *keys )
 
-    deleted_keys = []
+    #Hash[ keys.flatten.collect{ | key | [ key, delete( key ) ] if has_key?( key ) }.compact ]
 
-    Hash[ keys.flatten.collect{ | key | [ key, delete( key ) ] if has_key?( key ) }.compact ]
+    # optimized version, approx 23.4% faster
+    keys.inject( {} ){ | hash, key | hash[ key ] = delete( key ) if has_key?( key ); hash }
     
   end
   
@@ -110,22 +119,17 @@ class Hash
   def delete_keys( *keys )
   
     # create a duplicate of current hash
-    result = dup
+    result = dup; keys.flatten.each{ | key | result.delete( key ) }; result
 
-    keys.flatten.each{ | key | result.delete( key ) }
-    
-    result
+    # optimized version, approx 5% faster
+    #keys.inject( dup ){ | hash, key | hash.delete( key ); hash }
 
   end
 
   # store keys and values to hash if not already defined
   def default_values( hash )
 
-    hash.each_pair{ | key, value |
-
-      self[ key ] = value unless has_key?( key )
-
-    }
+    hash.each_pair{ | key, value | self[ key ] = value unless has_key?( key ) }
 
     self
 
@@ -142,6 +146,7 @@ class Hash
 
   def strip_dynamic_attributes!
 
+=begin
     # remove dynamic attributes from hash and return as result     
     Hash[ 
 
@@ -167,7 +172,58 @@ class Hash
       } 
 
     ]
+=end
+
+    # optimized version, approx 3.2% faster     
+    prefix = '__'
+
+    keys.inject( {} ){ | hash, key | 
+
+      hash[ key ] = delete( key ) if key.to_s[0..1] == prefix
+    
+      hash
+    
+    }
 
   end # strip_dynamic_attributes!
 
+  # TODO: document me
+  def recursive_merge( other )
+  
+    self.merge( other ){ | key, old_value, new_value |
+
+      new_value
+
+      if old_value.kind_of?( Hash ) && new_value.kind_of?( Hash )
+      
+        # merge hashes, call self recursively
+        old_value.recursive_merge( new_value )
+
+      elsif old_value.kind_of?( Array ) && new_value.kind_of?( Array )
+
+        # concatenate arrays
+        old_value.clone.concat( new_value ).uniq
+      
+      else
+
+        # return new value as is
+        new_value
+      
+      end
+
+    }
+  
+  end # recursive_merge
+
+  # TODO: document me
+  def recursive_merge!( other )
+  
+    self.replace( 
+    
+      recursive_merge( other )
+      
+    )
+  
+  end # recursive_merge!
+
 end

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

@@ -49,11 +49,32 @@ class Numeric
   end
 
   # TODO: document me
-  def limit( minimum_value, maximum_value )
+  def check_range( range, message = "value $1 is out of range ($2)"  )
+
+    # check that given argument is type of Range
+    raise TypeError, 'wrong argument type #{ range.class } for range (expected Range)' unless range.kind_of?( Range )
+
+    # check that given argument is type of Range
+    raise TypeError, 'wrong argument type #{ message.class } for exception message (expected String)' unless message.kind_of?( String )
+
+    # replace macros
+    message.gsub!( '$1', self.inspect )
+    
+    message.gsub!( '$2', range.inspect )
 
-    value = self    
+    # raise exception if number is out of range
+    raise RangeError, message unless range.include?( self )
+    
+    # return self
+    self
+    
+  end
+
+  # TODO: document me
+  def limit( minimum_value, maximum_value )
 
-    value.min( minimum_value ).max( maximum_value )
+    # limit current value
+    self.min( minimum_value ).max( maximum_value )
 
   end
 
@@ -66,7 +87,7 @@ class Numeric
 
     else
 
-      raise TypeError, 'wrong type %2 for value (expected Numeric)'
+      raise TypeError, "wrong type #{ value.class } for value (expected Numeric)"
 
     end
 
@@ -81,7 +102,7 @@ class Numeric
 
     else
 
-      raise TypeError, 'wrong type %2 for value (expected Numeric)'
+      raise TypeError, "wrong type #{ value.class } for value (expected Numeric)"
 
     end
 

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

@@ -20,8 +20,23 @@
 # extend Ruby Object class functionality
 class Object
 
+  # TODO: document me
+  def blank?
+  
+    respond_to?( :empty? ) ? empty? : !self
+  
+  end
+
+  def not_blank( message = "Object must not be blank", exception = ArgumentError )
+
+    raise exception, message if blank? 
+
+    self
+
+  end
+
   # define method to class instance
-  def meta_def method_name, &block
+  def meta_def( method_name, &block )
   
     ( class << self; self; end ).instance_eval{ define_method method_name, &block }
     
@@ -31,10 +46,10 @@ class Object
   def check_type( types, message = "wrong argument type $1 (expected $2)" )
 
     # raise exception if message is not type of String
-    raise TypeError.new( "wrong argument type %s for message (expected String)" % [ message.class ] ) unless message.kind_of?( String )
+    raise TypeError, "wrong argument type #{ message.class } for message (expected String)" unless message.kind_of?( String )
 
     # create array of types
-    type_array = types.kind_of?( Array ) ? types : [ types ]
+    type_array = Array( types )
 
     # default result value
     found = false
@@ -42,23 +57,29 @@ class Object
     # collect verbose type list
     verbose_type_list = type_array.each_with_index.collect{ | type, index | 
 
-      raise TypeError.new( "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 }?" unless type.kind_of?( Class )
+
+      if self.kind_of?( type )
+
+        found = true 
+
+        break
 
-      found = true if self.kind_of?( type )
+      end
 
       # result string, separate types if multiple types given
       "#{ ( ( index > 0 ) ? ( index + 1 < type_array.count ? ", " : " or " ) : "" ) }#{ type.to_s }"
           
-    }.join
+    }
 
     # raise exception if type did not match
     unless found
 
       # convert macros
-      [ self.class, verbose_type_list, self.inspect ].each_with_index{ | param, index | message.gsub!( "$#{ index + 1 }", param.to_s ) }
+      [ 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.new( message )
+      raise TypeError, message
 
     end
 
@@ -69,17 +90,19 @@ class Object
 
   def not_nil( message = "Value must not be nil", exception = ArgumentError )
 
-    raise exception.new( message ) if self.nil? 
+    raise exception, message unless self
+
+    self
 
   end
 
   def validate( values, message = "Unexpected value $3 for $1 (expected $2)" )
 
     # raise exception if message is not type of String
-    raise TypeError.new( "wrong argument type %s for message (expected String)" % [ message.class ] ) unless message.kind_of?( String )
+    raise TypeError, "wrong argument type #{ message.class } for message (expected String)" unless message.kind_of?( String )
 
     # create array of values
-    values_array = values.kind_of?( Array ) ? values : [ values ]
+    values_array = Array( values )
 
     # default result value
     found = false
@@ -89,21 +112,27 @@ class Object
 
       raise TypeError.new( "Invalid argument type #{ value.class } for value (expected #{ self.class })" ) unless value.kind_of?( self.class )
 
-      found = true if self == value
+      if self == value
+      
+        found = true 
+        
+        break
+        
+      end
 
       # result string, separate types if multiple types given
       "#{ ( ( index > 0 ) ? ( index + 1 < values_array.count ? ", " : " or " ) : "" ) }#{ value.inspect }"
           
-    }.join
+    }
 
     # raise exception if value was not found
     unless found
 
       # convert macros
-      [ self.class, verbose_values_list, self.inspect ].each_with_index{ | param, index | message.gsub!( "$#{ index + 1 }", param.to_s ) }
+      [ 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.new( message )
+      raise ArgumentError, message
 
     end