testability-driver 1.0.3 → 1.0.4

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

@@ -21,6 +21,13 @@ module MobyUtil
 
   class Retryable
 
+    # TODO: document me
+    def self.sleep_retry_interval( time )
+
+      sleep( time )
+
+    end
+
     # Function to retry code block for x times if exception raises
     # == params
     # options:: Hash of options 
@@ -30,22 +37,21 @@ module MobyUtil
     # == returns
     def self.while( options = {}, &block )
 
-      options = { :tries => 1, :interval => 0, :exception => Exception }.merge( options )
+      # default options
+      options.default_values( :tries => 1, :interval => 0, :exception => Exception )
 
       attempt = 1
 
       begin
 
         # yield given block and pass attempt number as parameter
-        return yield( attempt )
+        yield( attempt )
 
       rescue *options[ :exception ]
-  
-        #if ( options[ :tries ] -= 1) > 0 && ![ *options[ :unless ] ].include?( $!.class )
 
         if ( attempt < options[ :tries ] ) && ![ *options[ :unless ] ].include?( $!.class )
 
-          sleep( options[ :interval ] ) if options[ :interval ] > 0
+          sleep_retry_interval( options[ :interval ] ) if options[ :interval ] > 0
 
           attempt += 1
 
@@ -57,8 +63,7 @@ module MobyUtil
         Kernel::raise $!
 
       end
-
-      nil
+      
     end
 
     # Function to retry code block until timeout expires if exception raises 
@@ -70,28 +75,41 @@ module MobyUtil
     # == returns
     def self.until( options = {}, &block )
 
-      options = { :timeout => 0, :interval => 0, :exception => Exception }.merge( options )      
+      # default options
+      options.default_values( :timeout => 0, :interval => 0, :exception => Exception )
+      
+      # store start time
       start_time = Time.now
 
+      # attempt number
+      attempt = 0
+
       begin
 
-        return yield
+        # execute block
+        yield( attempt )
 
       rescue *options[ :exception ]
 
         if (Time.now - start_time) <= options[ :timeout ] && ![ *options[ :unless ] ].include?( $!.class )
-          sleep( options[ :interval ] ) if options[ :interval ] > 0
+
+          sleep_retry_interval( options[ :interval ] ) if options[ :interval ] > 0
+
+          attempt += 1
+
           retry
+
         end
 
         # raise exception with correct exception backtrace
         Kernel::raise $!
 
-      end      
+      end
+
     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 # Retryable
 

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

@@ -0,0 +1,185 @@
+############################################################################
+## 
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+## All rights reserved. 
+## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
+## 
+## This file is part of Testability Driver. 
+## 
+## If you have questions regarding the use of this file, please contact 
+## Nokia at testabilitydriver@nokia.com . 
+## 
+## This library is free software; you can redistribute it and/or 
+## modify it under the terms of the GNU Lesser General Public 
+## License version 2.1 as published by the Free Software Foundation 
+## and appearing in the file LICENSE.LGPL included in the packaging 
+## of this file. 
+## 
+############################################################################
+
+module TDriver
+
+  class StackableValue
+
+    # TODO: document me
+    def initialize( value, explicit_format = [] )
+
+      @explicit_format = explicit_format.kind_of?( Array ) ? explicit_format : [ explicit_format ]
+
+      @stack = []
+
+      push( value )
+
+    end
+
+    # TODO: document me
+    def push( value )
+
+      unless @explicit_format.empty?
+
+        found = false
+
+        # collect verbose type list
+        verbose_type_list = @explicit_format.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 )
+
+          found = true if value.kind_of?( type )
+
+          # result string, separate types if multiple types given
+          "#{ ( ( index > 0 ) ? ( index + 1 < @explicit_format.count ? ", " : " or " ) : "" ) }#{ type.to_s }"
+              
+        }.join
+
+        raise TypeError, "wrong variable format #{ value.class } for stackable value (expected #{ verbose_type_list })" unless found
+
+      end
+
+      # add to stack
+      @stack << value
+
+    end
+
+    # TODO: document me
+    def pop
+
+      @stack.pop unless ( @stack.count == 1 )
+
+      # return last value from stack
+      @stack.last
+
+    end
+
+    # TODO: document me
+    def restore
+
+      @stack = [ @stack.first ]
+
+      # return first value in stack array
+      @stack.last
+
+    end
+
+    # TODO: document me
+    def stacked?
+
+      # determine if there is values in stack
+      @stack.count > 1
+
+    end
+
+    # TODO: document me  
+    def to_s
+
+      # return last value in stack array as string
+      @stack.last.to_s
+
+    end
+
+    # TODO: document me
+    def inspect
+
+      # return inspect of last value in stack array
+      @stack.last.inspect
+
+    end
+
+    # TODO: document me
+    def count
+
+      # return size of the stack array
+      @stack.count
+
+    end
+
+    # TODO: document me
+    def first
+
+      # return first value in stack array
+      @stack.first
+
+    end
+
+    # TODO: document me
+    def last
+
+      # return last value in stack array
+      @stack.last
+
+    end
+
+    # TODO: document me
+    def []( value )
+
+      # return last one if index is too high
+      value = -1 if ( value > @stack.count - 1 )
+
+      @stack[ value ]
+
+    end
+
+    # TODO: document me
+    def []=( position, value )
+
+      # return last one if index is too high
+      value = -1 if ( position > @stack.count - 1 )
+
+      @stack[ position ] = value
+
+    end
+
+    # TODO: document me
+    def set( value )
+
+      @stack[ -1 ] = value
+
+    end
+
+    def ==( value )
+
+      @stack.last == value
+
+    end
+
+    # TODO: document me
+    def kind_of?( klass )
+
+      # compary stacked value class 
+      @stack.last.kind_of?( klass ) or klass == TDriver::StackableValue
+
+    end
+
+    # create required aliases
+    alias_method :size, :count
+
+    alias_method :<<, :push
+
+    alias_method :eql?, :==
+
+    alias_method :value=, :set
+
+    alias_method :value, :last
+
+  end # StackableValue
+
+end # TDriver

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

@@ -52,16 +52,32 @@ class String
   # string:: String
   # == returns
   # TrueClass/FalseClass 
-  def to_boolean
+  def to_boolean( *default )
 
     if /^(true|false)$/i.match( self.to_s )
     
       $1.downcase == 'true'
       
     else
-    
-      #default
-      Kernel::raise TypeError.new( "Unable to convert string \"#{ self }\" to boolean (Expected \”true\" or \"false\")" )
+        
+      # pass default value if string didn't contain boolean
+      if default.count > 0
+      
+        # retrieve first value from array
+        default = default.first
+        
+        # check that argument type is correct
+        default.check_type( [ TrueClass, FalseClass ], 'wrong argument type $1 for to_boolean default value argument (expecting $2)') 
+        
+        # return default value as result
+        default
+        
+      else
+      
+        # raise exception if no default given
+        Kernel::raise TypeError, "Unable to convert string \"#{ self }\" to boolean (Expected \"true\" or \"false\")"
+
+      end
 
     end
 
@@ -123,7 +139,7 @@ module MobyUtil
     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 # StringHelper
 

data/lib/tdriver/util/{dbaccess/dbaccess.rb → database/access.rb}

@@ -40,7 +40,7 @@ module MobyUtil
     # == description
     # Class Method that returns existing connections
     #
-    def DBAccess.connections()
+    def self.connections()
       return @@_connections
     end
     
@@ -216,6 +216,9 @@ module MobyUtil
 
     end
 
+    # enable hoo./base/test_object/factory.rb:king for performance measurement & debug logging
+    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+
   end # DBAccess
 
 end # MobyUtil

data/lib/tdriver/util/{dbaccess/dbconnection.rb → database/connection.rb}

@@ -34,6 +34,9 @@ module MobyUtil
 			@password = password
 			@dbh = nil		
 		end
+
+    # enable hoo./base/test_object/factory.rb:king for performance measurement & debug logging
+    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 		
 	end # class
 

data/lib/tdriver/util/{dbaccess → database}/error.rb

@@ -17,7 +17,6 @@
 ## 
 ############################################################################
 
-
 module MobyUtil
 
     # This error should be raised when no database type is defined

data/lib/tdriver/util/{dbaccess → database}/loader.rb

@@ -17,13 +17,12 @@
 ## 
 ############################################################################
 
-
-
-
 # dbaccess related errors
 require File.expand_path( File.join( File.dirname( __FILE__ ), 'error.rb' ) )
 
-# dbaccess module implementation 
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'dbaccess.rb' ) )
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'dbconnection.rb' ) )
+# database access module implementation
+require File.expand_path( File.join( File.dirname( __FILE__ ), 'access.rb' ) )
+
+# database connection module implementation
+require File.expand_path( File.join( File.dirname( __FILE__ ), 'connection.rb' ) )
 

data/lib/tdriver/util/{dynamic_attribute_filter.rb → filters/dynamic_attributes.rb}

@@ -181,7 +181,7 @@ module MobyUtil
 		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 # DynamicAttributeFilter
   

data/lib/tdriver/util/hooking/hooking.rb

@@ -0,0 +1,477 @@
+############################################################################
+## 
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+## All rights reserved. 
+## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
+## 
+## This file is part of Testability Driver. 
+## 
+## If you have questions regarding the use of this file, please contact 
+## Nokia at testabilitydriver@nokia.com . 
+## 
+## This library is free software; you can redistribute it and/or 
+## modify it under the terms of the GNU Lesser General Public 
+## License version 2.1 as published by the Free Software Foundation 
+## and appearing in the file LICENSE.LGPL included in the packaging 
+## of this file. 
+## 
+############################################################################
+module TDriver
+
+  class Hooking
+
+    # TODO: document me
+    class << self
+
+      @@non_wrappable_methods = [ 'instance' ]
+
+      # default values
+      @@wrapped_methods = {}
+      @@wrappee_count = 0
+
+      @@benchmark = {}
+
+      @@logger_instance = nil
+      
+      $tdriver_hooking = TDriver::Hooking
+      $tdriver_hooking_elapsed_time_stack = []
+
+    private
+
+      # Function to hook a method 
+      # == params
+      # base:: Class or Module
+      # method_name:: Name of the method  
+      # method_type:: public, private or static
+      # == returns
+      def hook_method( base, method_name, method_type )
+
+        # create only one wrapper for each method
+        unless @@wrapped_methods.has_key?( "#{ base.name }::#{ method_name }" )
+
+          # evaluate the generated wrapper source code
+          eval("base.#{ base.class.name.downcase }_eval( \"#{ make_wrapper( base, method_name.to_s, method_type.to_s )}\" )") if [ Class, Module ].include?( base.class )
+
+        end
+
+        nil
+
+      end
+
+      # Function to hook static methods for given Class or Module
+      # == params
+      # base:: Target Class or Module
+      # == returns
+      def hook_static_methods( _base )
+
+        if [ Class, Module ].include?( _base.class )
+
+          _base.singleton_methods( false ).each { | method_name |
+
+            hook_method( _base, method_name.to_s, "static" ) unless @@non_wrappable_methods.include?( method_name.to_s ) # method_name.to_s for ruby 1.9 compatibility
+
+          } 
+
+        end
+
+        nil
+
+      end
+
+      # Function to hook instance methods for given Class or Module
+      # == params
+      # base:: Target Class or Module
+      # == returns
+      def hook_instance_methods( _base )
+
+        if [ Class, Module ].include?( _base.class )        
+
+          { 
+            :public    => _base.public_instance_methods( false ), 
+            :private   => _base.private_instance_methods( false ), 
+            :protected => _base.protected_instance_methods( false ) 
+            
+          }.each{ | method_type, methods |
+
+            # method_name.to_s for ruby 1.9 compatibility
+            methods.each { | method_name | hook_method( _base, method_name.to_s, method_type.to_s ) unless /__wrappee_\d+/i.match( method_name.to_s ) } 
+
+          }
+
+        end
+
+        nil
+        
+      end
+
+      # Function to retrieve method path (e.g. Module1::Module2::Class1)
+      # == params
+      # base:: Target Class or Module
+      # == returns
+      # String:: Method path
+      def method_path( _base )
+
+        [ Class, Module ].include?( _base.class ) ? _base.name : _base.class.name
+
+      end
+
+      # Function to generate unique name for wrappee method
+      # == params
+      # method_name:: Name of the target method
+      # == returns
+      # String:: Unique name for wrappee method
+      def create_wrappee_name( method_name )
+
+        wrappee_name = "non_pritanble_method_name" if ( wrappee_name = ( /[a-z0-9_]*/i.match( method_name ) ) ).length == 0 
+
+        "__wrappee_#{ @@wrappee_count }__#{ wrappee_name }"
+
+      end
+
+      # Function for create source code of wrapper for method 
+      # == params
+      # base:: Class or Module
+      # method_name:: Name of the method  
+      # method_type:: public, private or static
+      # == returns
+      # String:: source code
+      def make_wrapper( base, method_name, method_type = nil )
+
+        # method name with namespace
+        base_and_method_name = "#{ base.name }::#{ method_name }"
+
+        # add method to benchmark table if enabled
+        if ENV[ 'TDRIVER_BENCHMARK' ].to_s.downcase == 'true'
+
+          @@benchmark[ base_and_method_name ] = { 
+            :time_elapsed       => 0, 
+            :times_called       => 0, 
+            :time_elapsed_total => 0 
+          } 
+
+        end
+
+        # create new name for original method 
+        original_method_name = create_wrappee_name( method_name )
+
+        # add method to wrapper methods list
+        @@wrapped_methods[ base_and_method_name ] = nil
+
+        @@wrappee_count += 1
+
+        case method_type
+
+          when 'public', 'private', 'static'
+
+            "#{
+              # this is needed if method is static
+              "class << self" if method_type == 'static' 
+
+              }
+
+                # create a copy of original method
+                alias_method :#{ original_method_name }, :#{ method_name }
+
+                #{ 
+
+                  if method_type == 'static'
+
+                    # undefine original version if static method
+                    "self.__send__( :undef_method, :#{ method_name } )"
+
+                  else
+
+                    # method visiblity unless method type is static
+                    "#{ method_type }"
+
+                  end
+
+                }
+
+                def #{ method_name }( *args, &block )
+
+                  # log method call
+                  $tdriver_hooking.log( '#{ method_path( base ) }.#{ method_name }', nil )
+
+                  #{
+
+                    if ENV[ 'TDRIVER_BENCHMARK' ].to_s.downcase == 'true'
+            
+                      "# store start time for performance measurement
+                      start_time = Time.now
+                      
+                      # Time elapsed in sub calls
+                      $tdriver_hooking_elapsed_time_stack << 0.0
+
+                      begin
+
+                        # call and return result of original method
+                        __send__(:#{ original_method_name }, *args, &block )
+
+                      rescue 
+
+                        raise $!
+                      
+                      ensure
+    
+                        # calculate actual elapsed time, including time elapsed in sub calls
+                        elapsed_time = Time.now - start_time
+
+                        # elapsed time in sub calls
+                        elapsed_time_in_subcalls = $tdriver_hooking_elapsed_time_stack.pop || 0
+                                                
+                        # add elapsed time to caller method 
+                        $tdriver_hooking_elapsed_time_stack[ -1 ] += elapsed_time unless $tdriver_hooking_elapsed_time_stack.empty?
+
+                        # store performance results to benchmark hash
+                        $tdriver_hooking.update_method_benchmark( '#{ base_and_method_name }', elapsed_time_in_subcalls, elapsed_time )
+
+                      end"
+
+                    else
+
+                      "# call original method
+                      __send__(:#{ original_method_name }, *args, &block )"
+
+                    end
+
+                  }
+
+                end
+
+              private :#{ original_method_name }
+
+              #{ 
+
+              # this is needed if method is static
+              "end" if method_type == 'static' 
+
+              }" 
+
+        end # case
+
+      end # make_wrapper
+
+    end # self
+
+    # TODO: document me
+    def self.wrappee_count
+
+      @@wrappee_count
+
+    end
+
+    # TODO: document me
+    def self.wrappee_count=( value )
+
+      @@wrappee_count = value 
+
+    end
+
+    # TODO: document me
+    def self.wrappee_methods
+
+      @@wrappee_methods
+
+    end
+
+    # TODO: document me
+    def self.wrappee_methods=( value )
+
+      @@wrappee_methods = value 
+
+    end
+
+
+    # TODO: document me
+    def self.benchmark
+
+      @@benchmark
+
+    end
+
+    # TODO: document me
+    def self.benchmark=( value )
+
+      @@benchmark = value
+
+    end
+
+    # TODO: document me
+    def self.logger_instance
+
+      @@logger_instance
+
+    end
+
+    # Function to set logger instance used by wrapper
+    # == params
+    # logger_instance:: Instance of TDriver logger
+    # == returns
+    def self.logger_instance=( logger_instance )
+
+      @@logger_instance = logger_instance
+
+    end
+
+    # Function to create logger event - this method is called from wrapper
+    # == params
+    # text:: Text sent from wrapper
+    # arguments:: Not in use
+    # == returns
+    def self.log( text, *arguments )
+
+      @@logger_instance.debug( text.to_s ) if @@logger_instance
+
+      nil
+
+    end
+
+    # Function to hook all instance and static methods of target Class/Module
+    # == params
+    # base:: Target Class or Module
+    # == returns
+    def self.hook_methods( _base )
+
+      hook_static_methods( _base )
+
+      hook_instance_methods( _base )
+
+      nil
+
+    end
+
+    # Function to update method runtime & calls count for benchmark
+    # == params
+    # method_name:: Name of the target method
+    # time_elapsed_in_subcalls:: 
+    # total_time_elapsed:: 
+    def self.update_method_benchmark( method_name, time_elapsed_in_subcalls, total_time_elapsed )
+
+      @@benchmark[ method_name ].tap{ | hash | 
+
+        hash[ :time_elapsed       ] += total_time_elapsed - time_elapsed_in_subcalls
+        hash[ :time_elapsed_total ] += total_time_elapsed
+        hash[ :times_called       ] += 1  
+
+      }
+
+    end
+
+    def self.print_benchmark( rules = {} )
+
+      total_run_time = 0
+
+      # :sort => :total_time || :times_called || :average_time
+
+      rules = { :sort => :total_time, :order => :ascending, :show_uncalled_methods => true }.merge( rules )
+
+      puts "%-80s %8s %15s %15s %9s %15s" % [ 'Name:',  'Calls:', 'Time total:', 'W/O subcalls:', '%/run', 'Total/call:' ]
+      puts "%-80s %8s %15s %15s %9s %15s" % [ '-' * 80, '-' * 8,  '-' * 15,      '-' * 15,        '-' * 8, '-' * 15      ]
+
+      table = @@benchmark
+
+      # calculate average time for method
+      table.each{ | key, value |
+      
+        table[ key ][ :average_time ] = ( value[ :times_elapsed_total ] == 0 || value[ :times_called ] == 0 ) ? 0 : value[ :time_elapsed_total ] / value[ :times_called ] 
+        
+        total_run_time += value[ :time_elapsed ]
+
+      }
+
+      table = table.sort{ | method_a, method_b | 
+
+        case rules[ :sort ]
+
+          when :name
+            method_a[ 0 ] <=> method_b[ 0 ]
+
+          when :times_called
+            method_a[ 1 ][ :times_called ] <=> method_b[ 1 ][ :times_called ]
+
+          when :total_time
+            method_a[ 1 ][ :time_elapsed_total ] <=> method_b[ 1 ][ :time_elapsed_total ]
+
+          when :total_time_no_subs
+            method_a[ 1 ][ :time_elapsed ] <=> method_b[ 1 ][ :time_elapsed ]
+
+          when :percentage
+          
+            ( ( method_a[ 1 ][ :time_elapsed ].to_f / total_run_time.to_f ) * 100 ) <=> ( ( method_b[ 1 ][ :time_elapsed ].to_f / total_run_time.to_f ) * 100 )
+
+          when :average_time
+            method_a[ 1 ][ :average_time ] <=> method_b[ 1 ][ :average_time ]
+
+        else
+
+          Kernel::raise ArgumentError.new("Invalid sorting rule, valid rules are :name, :times_called, :total_time, :total_time_no_subs, :percentage or :average_time")
+
+        end
+
+      }
+
+      case rules[ :order ]
+
+        # do nothing
+        when :ascending
+
+        when :descending
+          table = table.reverse
+
+      else
+
+        Kernel::raise ArgumentError.new("Invalid sort order rule, valid rules are :ascending, :descending")  
+
+      end
+
+      total_percentage = 0.0
+      total_time_elapsed_total = 0.0
+      total_average = 0.0
+      total_calls = 0
+
+      table.each{ | method | 
+
+        puts "%-80s %8s %15.8f %15.8f %8.3f%% %15.8f" % [ 
+          method[ 0 ], 
+          method[ 1 ][ :times_called ], 
+          method[ 1 ][ :time_elapsed_total ], 
+          method[ 1 ][ :time_elapsed ], 
+          
+          ( ( method[ 1 ][ :time_elapsed ].to_f / total_run_time.to_f ) * 100 ),
+          
+          method[ 1 ][ :average_time ] 
+        ] unless !rules[ :show_uncalled_methods ] && method[ 1 ][ :times_called ] == 0
+
+        total_percentage += ( ( method[ 1 ][ :time_elapsed ].to_f / total_run_time.to_f ) * 100 )
+
+        total_calls += method[ 1 ][ :times_called ]
+        total_time_elapsed_total += method[ 1 ][ :time_elapsed_total ]        
+        total_average += method[ 1 ][ :average_time ]
+
+      }
+
+      puts "%-80s %8s %15s %15s %9s %15s" % [ '-' * 80, '-' * 8, '-' * 15, '-' * 15, '-' * 8, '-' * 15 ]
+
+      puts "%-80s %8s %15.6f %15.6f %8.3f%% %15.8f" % [ 'Total:', total_calls, total_time_elapsed_total, total_run_time, total_percentage, total_average ]
+
+    end
+
+  end # Hooking
+
+end # TDriver
+
+# deprecated
+module MobyUtil
+
+  class Hooking
+
+    def self.instance
+
+      TDriver::Hooking
+
+    end
+
+  end # Hooking
+
+end # MobyUtil