testability-driver 1.0.3 → 1.0.4

data/lib/tdriver/util/loader.rb

@@ -17,49 +17,55 @@
 ## 
 ############################################################################
 
-
 require 'singleton'
+
 require 'rubygems'
 
-# Hooking module - should be loaded first due to above modules uses its functions
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'hooking.rb' ) )
+[ 
+  # hooking module - should be loaded first due to above modules uses its functions
+  'hooking/hooking.rb', 
+
+  # common utility modules
+  'common/loader.rb',
+
+  # logger module
+  'logger/logger.rb',
 
-# generic/common utility modules
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'common/loader.rb' ) )
+  # parameter modules
+  'xml/loader.rb',
 
-# Logger module
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'logger.rb' ) )
+  # statistics module
+  'statistics/statistics.rb',
 
-# Parameter modules
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'xml/loader.rb' ) )
+  # dynamic attribute filter module
+  'filters/dynamic_attributes.rb', 
 
-# Statistics module
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'stats.rb' ) )
+  # plugin service modules
+  'plugin/loader.rb', 
 
-# Dynamic attribute filter module
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'dynamic_attribute_filter' ) )
+  # parameter modules
+  'parameter/loader.rb', 
 
-# Plugin service & abstract class
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'plugin/loader.rb' ) )
+  # database access module
+  'database/loader.rb', 
 
-# Parameter modules
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'parameter/loader.rb' ) )
+  # localisation module
+  'localisation/loader.rb', 
 
-# DBAccess module
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'dbaccess/loader.rb' ) )
+  # user data module
+  'user_data/loader.rb', 
 
-# Localisation module
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'localisation/loader.rb' ) )
+  # operator data module
+  'operator_data/loader.rb', 
 
-# User Data module
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'user_data/loader.rb' ) )
+  # recorder and scripter modules
+  'recorder/loader.rb', 
 
-# Operator Data module
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'operator_data/loader.rb' ) )
+  # video capture/util modules
+  'video/loader.rb'
 
-# Recorder module
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'recorder.rb' ) )
+].each{ | filename |
 
-# Video utils module
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'video_utils.rb' ) )
+  require File.expand_path( File.join( File.dirname( __FILE__ ), filename ) )
 
+}

data/lib/tdriver/util/localisation/error.rb

@@ -17,7 +17,6 @@
 ## 
 ############################################################################
 
-
 module MobyUtil
 
 	# This error should be raised when referred language is not found

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

@@ -17,12 +17,9 @@
 ## 
 ############################################################################
 
-
-
-
 # localisation related errors
 require File.expand_path( File.join( File.dirname( __FILE__ ), 'error.rb' ) )
 
-# localisation module implementation 
+# localisation module implementation - load only if needed
 require File.expand_path( File.join( File.dirname( __FILE__ ), 'localisation.rb' ) )
 

data/lib/tdriver/util/localisation/localisation.rb

@@ -17,17 +17,18 @@
 ##
 ############################################################################
 
+# TODO: refactor to use MobyUtil::XML
 require 'nokogiri'
 
 # Utility for handling localisation database
-
 module MobyUtil
 
 	class Localisation
     
     # == Language maping cross-referenced from Nokia Shared Lancuage Codes and Symbian 
-    # http://developer.symbian.org/main/documentation/reference/s3/pdk/GUID-31C133DE-F245-5992-9A41-20A99291E72A.html
-    # http://www2.connecting.nokia.com/nokia/terminology/terms.nsf/document/ES346PMF37?OpenDocument&ExpandSection=1#_Section1
+    #
+    # Please follow Nokia Language Guidelines.
+    #
     # Its also enumerated by TLanguage in e32lang.h in the Symbian code.
     # The ones only on e32lang.h are commented out
     @language_code_map = {
@@ -39,7 +40,7 @@ module MobyUtil
       "Swedish" => ["sv", "06"],
       "Danish" => ["da", "07"],
       "Norwegian" => ["no", "08"], 
-      "Finish" => ["fi", "09"],
+      "Finnish" => ["fi", "09"],
       "English US" => ["en_US", "10"],
       # "Swiss French" => ["SF", "11"],
       # "Swiss German" => ["SG", "12"],
@@ -106,7 +107,7 @@ module MobyUtil
       # "Moldavian" => ["MO", "73"],  
       "Mongolian" => ["mn", "74"],  
       # "Norwegian Nynorsk" => ["nn", "75"],  
-      "Portuguese BR" => ["pt_BP", "76"],  
+      "Portuguese BR" => ["pt_BR", "76"],  
       "Punjabi" => ["pa", "77"],  
       "Romanian" => ["ro", "78"],  
       "Servian" => ["sr", "79"], 
@@ -310,11 +311,11 @@ module MobyUtil
 				language += "_"
 			end
 			
-			db_type =  MobyUtil::Parameter[ :localisation_db_type, nil ]
-			host =  MobyUtil::Parameter[ :localisation_server_ip ]
-			username = MobyUtil::Parameter[ :localisation_server_username ]
-			password = MobyUtil::Parameter[ :localisation_server_password ]
-			database_name = MobyUtil::Parameter[ :localisation_server_database_name ]
+			db_type =  $parameters[ :localisation_db_type, nil ]
+			host =  $parameters[ :localisation_server_ip ]
+			username = $parameters[ :localisation_server_username ]
+			password = $parameters[ :localisation_server_password ]
+			database_name = $parameters[ :localisation_server_database_name ]
 			
 			db_connection = DBConnection.new(  db_type, host, database_name, username, password )
 			
@@ -393,11 +394,11 @@ module MobyUtil
 
 			# Get a connection to the DB
 			if db_connection.nil? or !db_connection.kind_of? MobyUtil::DBConnection
-				db_type =  MobyUtil::Parameter[ :localisation_db_type ]
-				host =  MobyUtil::Parameter[ :localisation_server_ip ]
-				database_name = MobyUtil::Parameter[ :localisation_server_database_name ]
-				username = MobyUtil::Parameter[ :localisation_server_username ]
-				password = MobyUtil::Parameter[ :localisation_server_password ]
+				db_type =  $parameters[ :localisation_db_type ]
+				host =  $parameters[ :localisation_server_ip ]
+				database_name = $parameters[ :localisation_server_database_name ]
+				username = $parameters[ :localisation_server_username ]
+				password = $parameters[ :localisation_server_password ]
 				
 				db_connection = DBConnection.new(  db_type, host, database_name, username, password )
 			end
@@ -565,7 +566,7 @@ module MobyUtil
       language_number = $2
       # select returns an array of [language, codes] that suite the conditional
       # codes is the array ["NokiaCode(2-leter)", "SymbianCode(number)"]
-      language = @language_code_map.select{|lang,codes| codes[1] == language_number}[0][1][0]   
+      language = @language_code_map.select{|lang,codes| codes[1] == language_number}.to_a[0][1][0] # Array conversion for ruby 1.9 compatibility
 			language = column_names_map[ language_number ] if !column_names_map.empty? and column_names_map.key?( language_number )
       
       io = open(file)
@@ -721,19 +722,21 @@ module MobyUtil
 		# Extracs application name used for FNAME from a given filename (removes language tags and file extension)
 		# Used only on .ts files
 		def self.parseFName(file)
-			fname = file.split('/').last
 			#(wordlist matching)
-			words = ["ar", "bg", "ca", "cs", "da", "de", "el", "en", "english-gb", "(apac)", "(apaccn)", "(apachk)", "(apactw)", "japanese", "thai", "us", "es", "419", "et", "eu", "fa", "fi", "fr", "gl", "he", "hi", "hr", "hu", "id", "is", "it", "ja", "ko", "lt", "lv", "mr", "ms", "nb", "nl", "pl", "pt", "br", "ro", "ru", "sk", "sl", "sr", "sv", "th", "tl", "tr", "uk", "ur", "us", "vi", "zh", "hk", "tw", "no"]
-			match = fname.scan(/_([a-zA-Z1-9\-\(\)]*)/)
-			if match
-				match.each do |m|
-					fname.gsub!("_#{m[0]}"){|s| ""} if words.include?( m[0].downcase )
-				end
-			end
-			fname.gsub!(".ts"){|s| ""} 
+			words = ["ar", "bg", "ca", "cs", "da", "de", "el", "en", "english-gb", "(apac)", "(apaccn)", "(apachk)", "(apactw)", "japanese", "thai", "us", "es", "419", "et", "eu", "fa", "fi", "fr", "gl", "he", "hi", "hr", "hu", "id", "is", "it", "ja", "ko", "lt", "lv", "mr", "ms", "nb", "nl", "pl", "pt", "br", "ro", "ru", "sk", "sl", "sr", "sv", "th", "tl", "tr", "uk", "ur", "us", "vi", "zh", "hk", "tw", "no", "gb", "cn"]
+      
+      fname = file.split('/').last
+      fname.gsub!(".ts"){|s| ""} 
+      fname_fragments = fname.split('_')
+      fname_fragments.each_index do |i|
+        fname_fragments[i] = "" if words.include?( fname_fragments[i].downcase )
+      end
+      fname_fragments.delete("")
+      fname = fname_fragments.join("_")
       language = file.split('/').last.gsub( fname + "_" ){|s| ""}.gsub(".ts"){|s| ""}
-			return fname, language  #gsub! will return nil if now subs are performed
-		end
+      return fname, "" if fname == language
+      return fname, language
+    end
 		
 	end # class
 

data/lib/tdriver/util/{common.rb → logger/loader.rb}

@@ -17,8 +17,6 @@
 ## 
 ############################################################################
 
-
-STDOUT.puts "Please require 'util/common/loader.rb' instead of 'util/common.rb'"
-
-require File.expand_path( File.join( File.dirname( __FILE__ ), 'common/loader.rb' ) )
+# logger module
+require File.expand_path( File.join( File.dirname( __FILE__ ), 'logger.rb' ) )
 

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

@@ -0,0 +1,574 @@
+############################################################################
+## 
+## 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 MobyUtil
+
+  class Logger
+
+    include Singleton
+
+    attr_reader :include_behaviour_info
+
+    def initialize
+
+      # Allow all levels to be reported - do not change this!
+      @custom_levels = ['debug', 'behaviour', 'info', 'warning', 'error', 'fatal']
+
+      #Log4r::Configurator.custom_levels *@custom_levels.collect{ | level | level.upcase }
+
+      #Log4r::Logger.root.level = Log4r::DEBUG
+
+      @enabled_stack = [ false ]
+
+      @logger_instance = nil
+
+      @logger_engine_loaded = false
+
+    end
+
+    def include_behaviour_info=( value )
+
+      value.check_type( [ TrueClass, FalseClass ], "wrong argument type $1 for include_behaviour_info (expected $2)" )
+
+      @include_behaviour_info = value
+
+    end
+
+    # allow reporting by passing level as method name, raise exception if method_id not found in @custom_levels array
+    def method_missing( method_id, *method_arguments )
+
+      method_id_str = method_id.to_s
+
+      if @custom_levels.include?( method_id_str )
+
+        log method_id_str, *method_arguments
+
+      else
+
+        # raise exception
+        super
+
+      end
+
+    end
+
+    # TODO: add documentation
+    def enabled
+
+      @enabled_stack[ -1 ]
+
+    end
+
+    # TODO: add documentation
+    def enabled=( value )
+
+      @enabled_stack[ -1 ] = value
+
+    end
+
+    # TODO: add documentation
+    def push_enabled( value )
+
+      # push current value to stack if given argument is other than boolean
+      value = @enabled_stack[ -1 ] unless [ TrueClass, FalseClass ].include?( value.class )
+
+      @enabled_stack << value
+
+    end
+
+    # TODO: add documentation
+    def pop_enabled
+
+      @enabled_stack.pop if @enabled_stack.count > 1
+
+    end
+
+    # TODO: add documentation
+    def set_report_level( report_level )
+
+      if @logger_engine_loaded
+
+        Log4r::Logger.root.level = report_level
+
+      else
+
+        nil
+
+      end
+
+    end
+
+    # TODO: add documentation
+    def new_logger( logger_name )
+
+      if @logger_engine_loaded
+
+        Log4r::Logger.new( logger_name )
+
+      else
+
+        nil
+
+      end
+
+    end
+
+    # TODO: add documentation
+    def get_logger( logger_name )
+
+      begin
+
+        if @logger_engine_loaded
+
+          Log4r::Logger.get( logger_name )
+
+        else
+
+          nil
+
+        end
+
+      rescue
+
+        Kernel::raise ArgumentError, "Logger #{ logger_name.inspect } not found"
+
+      end
+
+    end
+
+    # TODO: add documentation
+    def create_outputter( outputter_class, *args )
+
+      outputter_class.new *args
+
+    end
+
+    # TODO: add documentation
+    def add_outputter( logger_instance, outputter_instance )
+
+      logger_instance.add outputter_instance
+
+    end
+
+    # TODO: add documentation
+    def remove_outputter( logger_instance, outputter_instance )
+
+      logger_instance.remove outputter_instance
+
+    end
+
+    # TODO: add documentation
+    def set_outputter_pattern( outputter_instance, pattern )
+
+      if @logger_engine_loaded
+
+        # Allow only FileOutputter instances
+        Kernel::raise ArgumentError, 'Outputter instance not valid' if ![ Log4r::FileOutputter ].include?( outputter_instance.class )
+
+        # Allow only FileOutputter instances
+        Kernel::raise ArgumentError, 'Outputter pattern not valid, %M required by minimum' if !/\%M/.match( pattern ) 
+
+        # create pattern for outputter
+        outputter_instance.formatter = Log4r::PatternFormatter.new :pattern => pattern
+
+      end
+
+    end
+
+    # TODO: add documentation
+    # return logger instance
+    def self.[]( key )
+
+      get_logger key
+
+    end
+
+    # TODO: add documentation
+    def root
+
+      if @logger_engine_loaded
+
+        Log4r::Logger.global
+
+      else 
+
+        nil
+
+      end
+
+    end
+
+    # TODO: add documentation
+    def log( level, *text_array )
+
+      if @logger_instance && enabled
+
+        # convert to lowercase string
+        level = level.to_s.downcase
+
+        include_behaviour_info = @include_behaviour_info 
+
+        # debug log entries and logging by using TDriver.logging.info or MobyUtil::Logging.instance.info etc
+        if caller.first =~ /method_missing/
+
+          # get correct caller method
+          log_caller = caller.at( 1 )
+
+          # debug level
+          if log_caller =~ /hooking\.rb/
+
+            log_caller = caller.at( 3 ).first
+
+          end
+
+        elsif caller.first =~ /logger\.rb/
+
+          # do not add caller info if called from self
+          include_behaviour_info = false
+
+        else
+
+          # normal logging, e.g. behaviour logging from method etc
+          log_caller = caller.at( 0 )
+
+        end
+
+        # log text to given level if logging enabled
+        text_array.each{ | text |
+
+          @logger_instance.send level, ( include_behaviour_info && !text.empty? ) ? "#{ text.to_s } in #{ log_caller.to_s }" : text.to_s
+
+        }
+
+      end
+
+    end
+
+    def enable_raise_hooking
+
+      # hook Kernel.raise
+      def Kernel::raise( *exception )
+
+        begin
+
+          super *exception
+
+        rescue => raised_exception
+
+          raised_exception.backtrace.slice!( 0 )
+
+          $logger.log 'warning', *[ '', "(#{ raised_exception.class }) #{ raised_exception.message.split("\n") }", '', raised_exception.backtrace, '' ].flatten
+
+          super raised_exception
+
+        end
+
+      end
+
+    end
+
+    def set_debug_exceptions
+
+      if ARGV.include?( '--debug_exceptions' ) || $parameters[ :debug_exceptions, 'false' ].to_s.downcase == 'true'
+
+        ARGV.delete('--debug_exceptions')
+
+        # for debugging to see every occured exception
+        def Kernel.raise( *args )
+          #begin
+          # raise and catch exception  
+          super( *args )
+          #rescue
+          # remove wrapper call from backtrace 
+          # $!.backtrace.shift
+          #puts "%s: %s\nBacktrace: \n%s\n\n" % [ $!.class, $!.message, $!.backtrace.collect{ | line | "  %s" % line }.join("\n") ]
+          # raise exception again
+          # super $!          
+          #end
+        end
+
+        # hook Object(Kernel)#raise
+        ::Object.class_exec{ 
+
+          ::Kernel.module_exec{
+
+            alias_method :original_raise, :raise
+
+            def raise( *args )
+
+              begin
+
+                # raise and catch exception  
+                original_raise( *args )
+
+              rescue
+
+                # remove wrapper calls from backtrace
+                while $!.backtrace.first =~ /(logger\.rb).*(raise)/
+                
+                  $!.backtrace.shift
+                
+                end
+                
+                puts "[debug] %s: %s\n[debug] Backtrace: \n[debug] %s\n\n" % [ 
+                  $!.class, 
+                  $!.message, 
+                  $!.backtrace.collect{ | line | "  ... from %s" % line }.join("\n[debug] ") 
+                ]
+                
+                # raise exception again
+                original_raise $!
+
+              end            
+
+            end
+            
+          }
+        }
+
+      end
+
+    end
+
+    # TODO: add documentation
+    def enable_logging
+
+      set_debug_exceptions # if enabled
+
+      # returns logging level as string
+      logging_level = Parameter[ :logging_level, nil ]
+
+      # do not enable logging if no logging level is not defined
+      return nil if logging_level.nil?
+
+      # raise exception if wrong format for logging level
+      Kernel::raise RuntimeError, "Wrong logging level format '#{ logging_level }' defined in TDriver parameter/template XML (expected numeric string)" unless logging_level.numeric?
+
+      # convert to integer
+      logging_level = logging_level.to_i
+
+      # raise exception if unsupported logging level
+      Kernel::raise RuntimeError, "Unsupported logging level '#{ logging_level }' defined in TDriver parameter/template XML (expected 0..5)" unless ( 0..5 ).include?( logging_level )
+
+      @include_behaviour_info = $parameters[ :logging_include_behaviour_info, 'false' ].to_s.to_boolean
+
+      # UI state XML parse error logging - verify that all required parameters are configured and output folder is created succesfully
+      if MobyUtil::KernelHelper.to_boolean( $parameters[ :logging_xml_parse_error_dump, 'false' ] ) == true
+
+        begin
+
+          if $parameters[ :logging_xml_parse_error_dump_path, nil ].nil?
+
+            warn("Warning: Configuration parameter :logging_xml_parse_error_dump_path missing, disabling the feature...") 
+
+            # disable feature
+            raise ArgumentError
+
+          else
+
+            begin
+
+              # 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
+
+              warn("Warning: Unable to create log folder #{ $parameters[ :logging_xml_parse_error_dump_path ] } for corrupted XML UI state files")
+
+              # disable feature
+              raise ArgumentError
+
+            end
+
+          end
+
+          if $parameters[ :logging_xml_parse_error_dump_overwrite, nil ].nil?
+
+            warn("Warning: Configuration parameter :logging_xml_parse_error_dump_overwrite missing, using 'false' as default value")
+
+            $parameters[ :logging_xml_parse_error_dump_overwrite ] = 'false'
+
+          end
+
+        rescue ArgumentError => exception
+
+          # disable xml logging
+          $parameters[ :logging_xml_parse_error_dump ] = 'false'
+
+        rescue #Exception => exception
+
+          # disable xml logging
+          warn( "Warning: Disabling logging due to failure (#{ $!.class }: #{ $!.message })" )
+
+          $parameters[ :logging_xml_parse_error_dump ] = 'false'
+
+        end
+
+      else
+
+        warn("Warning: Configuration parameter :logging_xml_parse_error_dump missing, disabling the feature...") 
+        $parameters[ :logging_xml_parse_error_dump ] = 'false'
+
+      end
+      
+      unless logging_level.zero?
+
+        # logger output path
+        outputter_path = MobyUtil::FileHelper.expand_path( $parameters[ :logging_outputter_path ] )
+
+        require 'log4r'
+
+        require 'log4r/configurator'
+
+        Log4r::Configurator.custom_levels *@custom_levels.collect{ | level | level.upcase }
+
+        Log4r::Logger.root.level = Log4r::DEBUG
+
+        @logger_engine_loaded = true
+
+        # disable logging if exception is raised during 
+        begin
+
+          # create outputter folder if not exist
+          MobyUtil::FileHelper.mkdir_path( outputter_path )
+
+          # create new logger instance
+          new_logger( 'TDriver' )
+
+          # get logger object reference
+          @logger_instance = get_logger( 'TDriver' )
+
+          # create unique name for logfile or use default (TDriver.log)
+          filename = ( MobyUtil::StringHelper.to_boolean( Parameter[ :logging_outputter_unique_filename ] ) ? "TDriver_#{ Time.now.to_i }.log" : "TDriver.log" )
+
+          # check if outputter is enabled
+          if MobyUtil::StringHelper.to_boolean( Parameter[ :logging_outputter_enabled ] )
+
+            # create new outputter instance type of FileOutputter
+            outputter = create_outputter(
+
+              # outputter type
+              Log4r::FileOutputter, 
+
+              # outputter name
+              "TDriver_LOG",
+
+              # outputter filename 
+              :filename => File.join( outputter_path, filename ), 
+
+              # append to or truncate file
+              :trunc => MobyUtil::StringHelper.to_boolean( Parameter[ :logging_outputter_append ] ) == false, 
+
+              # logging level
+              :level => logging_level
+
+            ) 
+
+            # set outputter log event write pattern
+            set_outputter_pattern( outputter, Parameter[ :logging_outputter_pattern ] )
+
+            # add outputter to logger instance
+            add_outputter( @logger_instance, outputter )
+
+          end
+
+        rescue
+
+          $parameters[ :logging_level ] = '0'
+
+          @logger_instance = nil
+
+          @enabled_stack = [ false ]
+
+          warn("Warning: Disabling logging due to failure (#{ $!.class }: #{ $!.message })")
+
+          return nil
+
+        end
+
+        # debug logging
+        if ( logging_level == 1 )
+
+          # enable exception capturing on debug level
+          enable_raise_hooking
+
+          # pass logger instance to hooking module
+          TDriver::Hooking.logger_instance = MobyUtil::Logger.instance
+
+        end  
+
+        # enable logging
+        @enabled_stack = [ true ]
+
+        # log event: start logging
+        log( 'info' , "", "Logging engine started", "" )
+
+      end
+
+      report_status_at_exit
+
+    end
+
+    def report_status_at_exit
+
+      at_exit{
+
+        begin
+
+          exit_status = nil
+
+          case $!
+
+            when NilClass
+
+              exit_status = ['info', '', 'Execution finished succesfully', '']
+
+            when SystemExit
+
+              exit_status = ['info', '', 'Execution terminated by system exit', '' ]
+
+          else
+
+            exit_status = ['error', '', "Execution terminated with exception: %s: %s" % [ caller.first, $!.message.split("\n") ], '' ]
+
+          end
+
+          log( *exit_status )
+
+        rescue
+
+        end
+
+      }
+    end
+
+    def hook_methods( _base )
+
+      #STDOUT.puts "Use TDriver::Hooking instead of MobyUtil::Logging.hook_methods (#{ caller(1).first })"
+
+      TDriver::Hooking.hook_methods( _base ) #if @enabled
+
+    end
+
+  end # Logger
+  
+end # MobyUtil
+
+# set global variable pointing to parameter class
+$logger = MobyUtil::Logger.instance