cutedriver-driver 2.0.0.20210120164037

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

@@ -0,0 +1,109 @@
+############################################################################
+## 
+## 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 GemHelper
+
+    def self.create_build_files
+
+      # Create build files. These are required, as RubyGems expects that external dependencies 
+      # are built during the gem installation process and will not complete the installation 
+      # if these files are missing.
+
+      begin
+
+        # remove following line when native extensions are supported by tdriver
+        #raise LoadError
+
+        # skip native extension build if running in java environment
+        raise LoadError if MobyUtil::EnvironmentHelper.java?
+
+        # skip also if windows env. until proper solution found how to compile in windows env.
+        raise LoadError if MobyUtil::EnvironmentHelper.windows? 
+
+        # makefile creation module
+        require 'mkmf'
+        
+        # name of ruby native extension
+        extension_name = 'tdriver/native_extensions'
+
+        # destination
+        dir_config( extension_name )
+
+        # create makefile for implementation 
+        create_makefile( extension_name )
+
+      rescue Exception
+
+        # create dummy makefile if building native extension fails or is not supported
+        File.open( 'Makefile', 'w' ) { | f | f.write "all:\n\ninstall:\n\n" }
+
+        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
+
+          File.open( 'make', 'w' ){ | f | f.write '#!/bin/sh'; f.chmod f.stat.mode | 0111; }
+          File.open( 'extconf.so', 'w' ) {}
+
+        end
+
+      end
+
+    end
+
+    def self.grant_file_access_rights( folder, user_name = nil, user_group = nil )
+
+      if MobyUtil::EnvironmentHelper.posix?
+
+        # change folder ownership to user and add writing access to each file
+        user_name = MobyUtil::EnvironmentHelper.user_name if user_name.nil?
+        user_group = MobyUtil::EnvironmentHelper.user_group( user_name ) if user_group.nil?
+
+        MobyUtil::EnvironmentHelper.change_file_ownership!( folder, user_name, user_group, true )
+
+        `chmod -R u+w #{ folder }`
+
+      end
+
+    end
+
+    # TODO: document
+    def self.install( *parameters, &block )
+
+      raise ArgumentError.new( "Target folder must be specified as first argument" ) if parameters.empty?
+
+      yield( *parameters )
+
+      MobyUtil::GemHelper.create_build_files
+
+      MobyUtil::GemHelper.grant_file_access_rights( parameters.first )
+
+    end
+
+    # enable hooking for performance measurement & debug logging
+    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+
+  end # GemHelper
+
+end # MobyUtil

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

@@ -0,0 +1,288 @@
+############################################################################
+## 
+## 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, message, caller if empty? 
+
+    self
+
+  end
+
+  # 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 )
+
+    found = false
+
+    verbose_keys_list = keys_array.each_with_index.collect{ | key, index | 
+
+      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 }"
+          
+    }
+
+    # raise exception if type did not match
+    unless found
+
+      # convert macros
+      [ verbose_keys_list.join ].each_with_index{ | param, index | message.gsub!( "$#{ index + 1 }", param.to_s ) }
+
+      # raise the exception
+      raise ArgumentError, message, caller
+
+    end
+
+    self
+
+  end
+
+  # verify that receiver object contains given key. Raises exception is key not found.
+  def require_key( key, message = 'required key $1 not found from hash' )
+  
+    # store caller backtrace before calling fetch
+    backtrace = caller
+  
+    fetch( key ){
+    
+      raise ArgumentError, message.gsub( "$1", key.inspect ), backtrace
+    
+    }
+  
+  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
+    keys_array = Array( keys )
+
+    found = true
+
+    verbose_keys_list = keys_array.each_with_index.collect{ | key, index | 
+
+      found = false unless has_key?( key )
+
+      # result string, separate types if multiple types given
+      "#{ ( ( index > 0 ) ? ( index + 1 < keys_array.count ? ", " : " and " ) : "" ) }#{ key.inspect }"
+          
+    }
+
+    # raise exception if type did not match
+    unless found
+
+      # convert macros
+      [ verbose_keys_list.join ].each_with_index{ | param, index | message.gsub!( "$#{ index + 1 }", param.to_s ) }
+
+      # raise the exception
+      raise ArgumentError, message, caller
+
+    end
+
+    self
+
+  end
+
+  # collect given keypairs from hash 
+  def collect_keys( *keys )
+  
+    #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 )
+
+    #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
+  
+  # delete multiple keys from hash, does not modify original hash
+  def delete_keys( *keys )
+  
+    # create a duplicate of current hash
+    result = dup; 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 ) }
+
+    self
+
+  end
+
+  # store key and value to hash if not already defined
+  def default_value( key, value )
+
+    self[ key ] = value unless has_key?( key )
+
+    self
+
+  end
+
+  def strip_dynamic_attributes!
+
+=begin
+    # 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
+
+    # 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 to_attributes
+  
+    collect{ | key, value |
+
+      "#{ key.to_s }=\"#{ value.to_s.encode_to_xml }\"" 
+  
+    }.join(" ")
+  
+  end
+
+  # TODO: document me
+  def recursive_merge( other )
+  
+    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 )
+  
+    replace( 
+    
+      recursive_merge( other )
+      
+    )
+  
+  end # recursive_merge!
+
+  # 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

@@ -0,0 +1,253 @@
+############################################################################
+## 
+## 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 Kernel
+
+
+  # TODO: document me
+  def __method_path__
+
+    # retrieve filename, line number and method name
+    /^(.+?):(\d+)(?::in `(.*)')?/.match( caller.reverse[ -2 ].to_s )
+
+    # construct string with module/class and method name
+    "#{ ( [ Class, Module ].include?( self.class ) ? self.name : self.class.name ).to_s }##{ caller.first.to_s.scan(/`(.+)'$/).to_s }"
+
+  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 verify block for 
+  # constant verifications for sut state
+  class VerifyBlock 
+
+    attr_accessor :block,:expected, :message,:source, :timeout
+
+    def initialize(block, expected, message = nil, timeout = nil, source = "")
+
+      @block = block
+      @expected = expected
+      @message = message
+      @timeout = timeout
+      @source = source
+
+    end
+
+  end
+
+  class KernelHelper
+
+    # Function to determine if given value is boolean
+    # == params
+    # value:: String containing boolean
+    # == returns
+    # TrueClass::
+    # FalseClass::
+    def self.boolean?( value )
+
+      /^(true|false)$/i.match( value.to_s ).kind_of?( MatchData ) rescue false
+
+    end
+
+    # Function to return boolean of given value
+    # == params
+    # value:: String containing boolean
+    # == returns
+    # TrueClass::
+    # FalseClass::
+    def self.to_boolean( value, default = nil )
+
+      /^(true|false)$/i.match( value.to_s ) ? $1.downcase == 'true' : default
+
+    end
+
+    # Function to return class constant from a string
+    # == params
+    # constant_name:: String containing path
+    # == returns
+    # Class
+    def self.get_constant( constant_name )
+
+      begin
+
+        constant_name.split("::").inject( Kernel ){ | scope, const_name | scope.const_get( const_name ) }
+
+      rescue 
+
+        raise NameError, "invalid constant #{ constant_name }"
+
+      end
+
+    end
+
+    def self.parse_caller( at )
+
+      if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
+
+        file = Regexp.last_match[ 1 ]
+        line = Regexp.last_match[ 2 ].to_i
+        method = Regexp.last_match[ 3 ]
+
+        [ file, line, method ]
+
+      end
+
+    end
+
+    def self.deprecated( deprecated_name, new_name = "" )
+
+      output = "warning: #{ deprecated_name } is deprecated"
+
+      output += "; use #{ new_name } instead" unless new_name.empty?
+
+      $stderr.puts output
+
+    end
+
+    # Searches for the given source file for a line
+    #
+    # === params
+    # from_file:: String defining the file to load. If at_line is nil, this argument can also contain a path and line number separated by : (eg. some_dir/some_file.rb:123).
+    # at_line:: (optional) Integer, number of the line (first line is 1).
+    # === returns
+    # String:: Contents of the line
+    # === throws
+    # RuntimeError:: from_file is not correctly formed, the file cannot be loaded or the line cannot be found.
+    def self.find_source( backtrace )
+
+      result = "\n"
+
+      begin
+
+        # split with colon 
+        call_stack = backtrace.to_s.split(':')
+          
+        # TODO: document me      
+        line_number = ( call_stack.size == 2 ? call_stack[ 1 ].to_i : call_stack[ call_stack.size - 2 ] ).to_i
+
+        file_path = ""
+        
+        # TODO: document me      
+        if ( call_stack.size == 2 )
+        
+          file_path = call_stack[ 0 ]
+          
+        else
+        
+          # TODO: document me      
+          ( call_stack.size - 2 ).times do | index |
+          
+            file_path << "#{ call_stack[ index ].to_s }:"
+            
+          end
+          
+          # remove the trailing colon
+          file_path.slice!(-1)
+          
+        end
+        
+        # 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
+
+        # expand file path and name 
+        filename = File.expand_path( file_path.to_s )
+
+        # 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
+          raise RuntimeError.new(
+          
+            "Unable to fetch line #{ start_line.to_s } from source file #{ filename } due to it is out of range (total lines: #{ 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 |
+
+            # add "=>" to line which failed                       
+            result << ( ( line_number == ( start_line + index ) ) ? "=> " : "   " ) + lines[ start_line + index - 1 ]
+            
+          end
+
+        }
+
+      rescue Exception => e
+
+        result << "Unable to load source lines.\n#{ e.inspect }"
+
+      end
+
+      # return result string
+      result
+
+    end
+
+    # enable hooking for performance measurement & debug logging
+    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+
+  end # KernelHelper
+
+end # MobyUtil