testability-driver 0.9.2 → 1.0.0

data/lib/tdriver/tdriver.rb

@@ -25,11 +25,16 @@
 #
 # Please see class documentation for more info
 
+# initializing TDriver
+$TDRIVER_INITIALIZED = false
+
+# unicode support
 $KCODE = 'u'
 
-# Following line to prevent Object#id Warnings
+# prevent Object#id Warnings
 Object.send( :undef_method, :id ) if Object.respond_to?( :id )
 
+# load all required components
 require File.expand_path( File.join( File.dirname( __FILE__ ), 'loader' ) )
 
 module TDriver
@@ -49,15 +54,10 @@ module TDriver
 	# Object:: Object that SutFactory returns 
 	# === example
 	#  @sut = TDriver.connect_sut(:Id =>'sut_qt') # for qt, id in configuration file sut_qt
-	def self.connect_sut( sut_attributes = {} )    
-
-		# if given arguments is type of Symbol expect is as SUT id
-		sut_attributes = { :Id => sut_attributes } if sut_attributes.kind_of? Symbol
+	def self.connect_sut( sut_attributes = {} )
 
-		Kernel::raise ArgumentError.new( "Wrong argument type '%s' (Expected Hash)" % sut_attributes.class ) unless sut_attributes.kind_of?( Hash )
-		Kernel::raise ArgumentError.new( "Sut id not given!" ) unless sut_attributes.has_key?( :Id )
+		MobyBase::SUTFactory.instance.make( sut_attributes )
 
-		MobyBase::SUTFactory.instance.make( sut_attributes[ :Id ] )
 	end
 
 	# Function to disconnect SUT object.  
@@ -73,13 +73,7 @@ module TDriver
 	#  @sut = TDriver.disconnect_sut(:Id =>'sut_qt') # for qt, should be connected already
 	def self.disconnect_sut( sut_attributes = {} )
 
-		# if given arguments is type of Symbol expect is as SUT id
-		sut_attributes = { :Id => sut_attributes } if sut_attributes.kind_of? Symbol
-
-		Kernel::raise ArgumentError.new( "Wrong argument type '%s' (Expected Hash)" % sut_attributes.class ) unless sut_attributes.kind_of?( Hash )
-		Kernel::raise ArgumentError.new( "Sut id not given!" ) unless sut_attributes.has_key?( :Id )
-
-		MobyBase::SUTFactory.instance.disconnect_sut( sut_attributes[ :Id ] )
+		MobyBase::SUTFactory.instance.disconnect_sut( sut_attributes )
 
 	end
 
@@ -94,13 +88,7 @@ module TDriver
 	#  @sut = TDriver.reboot_sut(:Id =>'sut_qt') # for Qt, should be connected already   
 	def self.reboot_sut( sut_attributes = {} )
 
-		# if given arguments is type of Symbol expect is as SUT id
-		sut_attributes = { :Id => sut_attributes } if sut_attributes.kind_of? Symbol
-
-		Kernel::raise ArgumentError.new( "Wrong argument type '%s' (Expected Hash)" % sut_attributes.class ) unless sut_attributes.kind_of?( Hash )
-		Kernel::raise ArgumentError.new( "Sut id not given!" ) unless sut_attributes.has_key?( :Id )
-
-		MobyBase::SUTFactory.instance.reboot_sut( sut_attributes[ :Id ] )
+		MobyBase::SUTFactory.instance.reboot_sut( sut_attributes )
 
 	end
 
@@ -134,25 +122,10 @@ module TDriver
 	# enable hooking for performance measurement & debug logging
 	MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
 
-
 end # TDriver
 
-if ARGV.include?( '--debug_exceptions' ) || TDriver.parameter[ :debug_exceptions, 'false' ].to_s.downcase == 'true'
-
-	# for debugging to see every occured exception
-	def Kernel::raise( *args )
-
-		exception = args.first || $!
-
-		backtrace = caller.collect{ | line | "  %s" % line }.join("\n")
-
-		puts "%s: %s\nBacktrace: \n%s\n\n" % [ exception.class, exception.message, backtrace ]
-
-		super
-
-	end
-
-end
-
-# Enable logging engine
+# enable logging engine
 MobyUtil::Logger.instance.enable_logging()
+
+# initialization done, everything is ready
+$TDRIVER_INITIALIZED = true

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

@@ -17,6 +17,7 @@
 ## 
 ############################################################################
 
+# TODO: move custom errors to exceptions.rb
 module MobyUtil
 
   # template for custom error classes

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

@@ -0,0 +1,12 @@
+# place all custom TDriver exception classes here
+class MobyStandardError < StandardError
+
+	# Construct a new error, optionally passing in a message
+	def initialize ( message = nil )
+	  super( message )
+	end
+	
+end
+
+# file not found error
+class FileNotFoundError < MobyStandardError; end;

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

@@ -60,7 +60,7 @@ module MobyUtil
 
         require_files = Dir.glob( MobyUtil::FileHelper.fix_path( path ) )
 
-        Kernel::raise ArgumentError.new( "File not found %s" % [ path ] ) if !File.directory?( path ) && !File.file?( path ) && require_files.empty?
+        Kernel::raise RuntimeError.new( "File not found %s" % [ path ] ) if !File.directory?( path ) && !File.file?( path ) && require_files.empty?
 
         # load each module found from given folder
         require_files.each { | module_name | 
@@ -81,7 +81,8 @@ module MobyUtil
     # String:: String presentation of fixed path
     def self.fix_path( path )      
 
-      Kernel::raise ArgumentError.new( "Invalid argument format %s (Expected: %s)" % [ path.class, "String" ] ) unless path.kind_of?( String )      
+      #Kernel::raise ArgumentError.new( "Invalid argument format %s (Expected: %s)" % [ path.class, "String" ] ) unless path.kind_of?( String )      
+      path.check_type( String, "Wrong argument type $1 for file path (expected $2)" )
 
       # replace back-/slashes to File::SEPARATOR
       path.gsub( /[\\\/]/, File::SEPARATOR ).to_s
@@ -113,8 +114,11 @@ module MobyUtil
     # ArgumentError:: Given path is empty
     def self.is_relative_path?( path )  
 
-      Kernel::raise ArgumentError.new("Unexpected argument type '%s' for path (Expected: %s)" % [ path.class, 'String' ] ) unless path.kind_of?( String )
-      Kernel::raise ArgumentError.new("Given path is empty") if path.empty?
+      #Kernel::raise ArgumentError.new("Unexpected argument type '%s' for path (Expected: %s)" % [ path.class, 'String' ] ) unless path.kind_of?( String )
+      path.check_type( String, "Wrong argument type $1 for file path (expected $2)" )
+
+      #Kernel::raise ArgumentError.new("Given path is empty") if path.empty?
+      path.not_empty( "Filepath must not be empty string" )
 
       dirname =  File.dirname( path )
 
@@ -236,7 +240,9 @@ module MobyUtil
     # IOError:: Error occured while creating folder
     def self.copy_file( source, destination, verbose = false, overwrite = true, create_folders = true, &block )
 
-      Kernel::raise ArgumentError.new( "Source and destination argument must be type of String" ) unless source.kind_of?( String ) && destination.kind_of?( String )
+      source.check_type( String, "Wrong argument type $1 for source file (expected $2)" )
+      
+      destination.check_type( String, "Wrong argument type $1 for destination file (expected $2)" )
 
       sources = []
 
@@ -273,7 +279,7 @@ module MobyUtil
         # create destination folder if it doesn't exist and create_folders flag is enabled
         MobyUtil::FileHelper.mkdir_path( destination_folder ) if create_folders
 
-        Kernel::raise RuntimeError.new( "Source file does not exist (#{ source })" ) unless File.exist?( source )
+        Kernel::raise RuntimeError.new( "Unable to copy %s to %s due to source file does not exist" % [ source, destination ] ) unless File.exist?( source )
 
         File.copy( 
 

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

@@ -58,6 +58,7 @@ module MobyUtil
         if MobyUtil::EnvironmentHelper.windows? 
 
           File.open( 'nmake.bat', 'w') { |f| f.write "SET ERRORLEVEL=0" }
+          File.open( 'make.bat', 'w') { |f| f.write "SET ERRORLEVEL=0" }
           File.open( 'extconf.dll', 'w' ) {}
 
         else
@@ -90,7 +91,7 @@ module MobyUtil
     # TODO: document
     def self.install( *parameters, &block )
 
-      Kernel::raise ArgumentError.new( "Target folder required as first argument" ) unless parameters.count > 0
+      Kernel::raise ArgumentError.new( "Target folder must be specified as first argument" ) if parameters.empty?
 
       yield( *parameters )
 

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

@@ -0,0 +1,152 @@
+############################################################################
+## 
+## 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. 
+## 
+############################################################################
+
+# extend Ruby Hash class functionality
+class Hash
+
+  def not_empty( message = "Hash must not be empty", exception = ArgumentError )
+
+    raise exception.new( message ) if self.empty? 
+
+  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" )
+
+    # create array of types
+    keys_array = keys.kind_of?( Array ) ? keys : [ keys ]    
+
+    found = false
+
+    verbose_keys_list = keys_array.each_with_index.collect{ | key, index | 
+
+      found = true if self.has_key?( key )
+
+      # 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 ) }
+
+      # raise the exception
+      raise ArgumentError.new( message )
+
+    end
+
+    self
+
+  end
+
+  # Verify that received 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
+    keys_array = keys.kind_of?( Array ) ? keys : [ keys ]    
+
+    found = true
+
+    verbose_keys_list = keys_array.each_with_index.collect{ | key, index | 
+
+      found = false unless self.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 ) }
+
+      # raise the exception
+      raise ArgumentError.new( message )
+
+    end
+
+    self
+
+  end
+
+  # collect given keypairs from hash 
+  def collect_keys( *keys )
+  
+    Hash[ self.select{ | key, value | true if keys.include?( key ) } ]
+  
+  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 )
+
+    }
+
+    self
+
+  end
+
+  # store key and avalue to hash if not already defined
+  def default_value( key, value )
+
+    self[ key ] = value unless has_key?( key )
+
+    self
+
+  end
+
+  def strip_dynamic_attributes!
+
+    # remove dynamic attributes from hash and return as result     
+    Hash[ 
+
+      # iterate through each hash key
+      select{ | key, value | 
+
+        # dynamic attribute name has "__" prefix
+        if key.to_s =~ /^__/ 
+
+          # remove dynamic attribute key from hash
+          delete( key )
+
+          # add to hash
+          true
+
+        else
+
+          # do not add to hash
+          false
+
+        end
+
+      } 
+
+    ]
+
+  end # strip_dynamic_attributes!
+
+end

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

@@ -117,67 +117,82 @@ module MobyUtil
     # RuntimeError:: from_file is not correctly formed, the file cannot be loaded or the line cannot be found.
     def self.find_source( backtrace )
 
-      ret_str = "\n"
+      result = "\n"
 
       begin
 
+        # split with colon 
         call_stack = backtrace.to_s.split(':')
-        #puts "call_stack:" << backtrace.to_s
-
-        line_number = 0
-        if (call_stack.size() == 2)
-          line_number = call_stack[1].to_i
-
-        else
-          line_number = call_stack[call_stack.size()-2].to_i
-        end
-        #puts "line number: " << line_number.to_s
+          
+        # TODO: document me      
+        line_number = ( call_stack.size == 2 ? call_stack[ 1 ].to_i : call_stack[ call_stack.size - 2 ] ).to_i
 
         file_path = ""
-        if (call_stack.size() == 2)
-          file_path = call_stack[0]
+        
+        # TODO: document me      
+        if ( call_stack.size == 2 )
+        
+          file_path = call_stack[ 0 ]
+          
         else
-          (call_stack.size()-2).times do |index|
-            file_path << call_stack[index].to_s << ":"
+        
+          # TODO: document me      
+          ( call_stack.size - 2 ).times do | index |
+          
+            file_path << "%s:" % call_stack[ index ]
+            
           end
-          file_path.slice!(file_path.size()-1) # remove the trailing colon
+          
+          # remove the trailing colon
+          file_path.slice!(-1)
+          
         end
-        #puts "file path: " << file_path.to_s
-
+        
+        # TODO: document me      
         lines_to_read = line_number >= 2 ? 3 : line_number
         #puts "lines to read: " << lines_to_read.to_s
 
+        # TODO: document me      
         start_line = line_number #- (lines_to_read <= 1 ? 0 : 1)
         #puts "start line:" << start_line.to_s
 
-        File.open(File.expand_path(file_path.to_s), "r") { |source|
+        # expand file path and name 
+        filename = File.expand_path( file_path.to_s )
 
-          lines = source.readlines
-          #puts "lines.size:" << lines.size
-          Kernel::raise RuntimeError.new("Only \"#{lines.size.to_s}\" lines exist in the source file.")if start_line > lines.size
-
-          lines_to_read = (lines.size - start_line + 1) < 3 ? (lines.size - start_line + 1) : lines_to_read
+        # open source file
+        File.open( filename, "r") { | source |
 
+          # read lines
+          lines = source.readlines
+          
+          # raise exception if line number is larger than total number of lines
+          Kernel::raise RuntimeError.new(
+          
+            "Unable to fetch line %s from source file %s due to it is out of range (total lines: %s)" %  [ start_line, filename, lines.size ]
+            
+          ) if start_line > lines.size
+
+          # TODO: document me
+          lines_to_read = ( lines.size - start_line + 1 ) < 3 ? ( lines.size - start_line + 1 ) : lines_to_read
+          
           # the array is zero based, first line is at position 0
-          lines_to_read.times do |index|
-            if (line_number == (start_line + index))
-              ret_str << "=> "
-            else
-              ret_str << "   "
-            end
-            ret_str << lines[start_line + index - 1]
+          lines_to_read.times do | index |
+
+            # add "=>" to line which failed                       
+            result << ( ( line_number == ( start_line + index ) ) ? "=> " : "   " ) + lines[ start_line + index - 1 ]
+            
           end
 
         }
 
       rescue Exception => e
 
-        #puts "exception:" << e.inspect
-        ret_str << "Unable to load source lines.\n" << e.inspect
+        result << "Unable to load source lines.\n#{ e.inspect }"
 
       end
 
-      return ret_str
+      # return result string
+      result
 
     end