testability-driver 1.1.1 → 1.2.1

data/config/sut_parameters.rb

@@ -19,6 +19,7 @@
 # Generic configuration file for sut data.
 # Can be used to provide ruby code for sut configurations.
 module SutParameters
+
   # Verify blocks define the verify_always blocks that are automatically added to given sut.  
   # Takes an array of VerifyBlock objects
   # VerifyBlock parameters:
@@ -27,13 +28,25 @@ module SutParameters
   # - Error message
   # Configured verify_always blocks will not return the failed error block code in the error message.
   VERIFY_BLOCKS = [
-                   # Example block
-                   MobyUtil::VerifyBlock.new(
-                                             Proc.new { |sut|
-                                               # Verifies that some application is always running
-                                               sut.application.name != "qttasserver"
-                                             }, 
-                                             true, "Top most application is qttas, no application is running")                                           
-                  ]
+  
+    # Example block
+    MobyUtil::VerifyBlock.new(
+
+      # proc block to execute
+      Proc.new{ |sut|
+        # Verifies that some application is always running
+        sut.application.name != "qttasserver"
+      }, 
+
+      # expected return value
+      true, 
+
+      # error message
+      "Top most application is qttas, no application is running"
+
+    )
+    
+  ]
+  
 end
   

data/config/tdriver_custom_error_recovery.rb

@@ -0,0 +1,83 @@
+############################################################################
+##
+## 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 TDriverCustomErrorRecovery
+
+  # This method is called by TDriver Reporter when error is detected in connection
+  # === params
+  # === returns
+  # === raises
+  def error_in_connection()
+
+  end
+
+  # This method is called by TDriver Reporter when test set execution is starting
+  # === params
+  # === returns
+  # === raises
+  def starting_test_set_run()
+
+  end
+
+  # This method is called by TDriver Reporter when test case execution is starting
+  # === params
+  # test_case: the test case name
+  # connected_suts: All the connected TDriver suts
+  # === returns
+  # === raises
+  def starting_test_case(test_case,connected_suts)
+
+  end
+
+  # This method is called by TDriver Reporter when a error is detected in test case execution
+  # === params
+  # connected_suts: All the connected TDriver suts
+  # === returns
+  # === raises
+  def error_in_test_case(connected_suts)
+
+  end
+
+  # This method is called by TDriver Reporter when test case details are updated
+  # === params
+  # details: Execution details recived from the current test case
+  # === returns
+  # === raises
+  def updating_test_case_details(details)
+
+  end
+
+  # This method is called by TDriver Reporter when test case execution is ended
+  # === params
+  # connected_suts: All the connected TDriver suts
+  # === returns
+  # === raises
+  def ending_test_case(status,connected_suts)
+
+  end
+
+  # This method is called by TDriver Reporter when test set execution is ending
+  # === params
+  # === returns
+  # === raises
+  def ending_test_set_run()
+
+  end
+    
+end

data/ext/extconf.rb

@@ -29,8 +29,9 @@ MobyUtil::GemHelper.install( MobyUtil::FileHelper.tdriver_home ){ | tdriver_home
     [ "../xml/parameters/tdriver_parameters.xml", "tdriver_parameters.xml", false ],
     [ "../xml/parameters/tdriver_parameters.xml", "default/tdriver_parameters.xml", true ],
     [ "../config/sut_parameters.rb", "sut_parameters.rb", true ],
-    [ "../config/sut_setup.rb", "sut_setup.rb", true ],
-    [ "../config/sut_teardown.rb", "sut_teardown.rb", true ],
+    [ "../config/sut_setup.rb", "sut_setup.rb", false ],
+    [ "../config/sut_teardown.rb", "sut_teardown.rb", false ],
+    [ "../config/tdriver_custom_error_recovery.rb", "tdriver_custom_error_recovery.rb", false ],
 
     # templates
     [ "../xml/templates/*.xml",  "templates/", true ],

data/ext/native_extensions.c

@@ -30,6 +30,7 @@ static const CRC_16[ 16 ] = {
 
 };
 
+/*
 static VALUE crc16_ibm( VALUE self, VALUE string ) {
 
   // verify argument type
@@ -55,16 +56,73 @@ static VALUE crc16_ibm( VALUE self, VALUE string ) {
 
 	return INT2FIX( ~crc & 0xffff );
 
+}
+*/
+
+//static VALUE crc16_ibm( VALUE self, VALUE string, VALUE unused_crc ) {
+static VALUE crc16_ibm( int argc, VALUE* argv, VALUE self ) { 
+  //klass VALUE self, VALUE string, VALUE unused_crc ) {
+
+  // variables for arguments
+  VALUE string, initial_crc;
+
+  // retrieve arguments
+  rb_scan_args(argc, argv, "11", &string, &initial_crc);
+
+  int crc; // = 0xffff;
+  
+  if (NIL_P(initial_crc)){
+  
+    crc = 0xffff; 
+  
+  } else {
+
+    // verify initial crc value
+    Check_Type( initial_crc, T_FIXNUM );
+  
+    crc = NUM2INT( initial_crc );
+  
+  }
+  
+  // verify argument type
+  Check_Type( string, T_STRING );
+
+  const char* data = RSTRING_PTR( string );
+  
+  int len = RSTRING_LEN( string );
+  
+  int c = 0;
+
+  while( len-- ){
+
+    c = *data++;
+
+    crc = ( crc >> 4 ) ^ CRC_16[ ( crc ^ c ) & 15 ];
+              
+    crc = ( crc >> 4 ) ^ CRC_16[ ( crc ^ ( c >> 4 ) ) & 15 ];
+
+  }
+
+	return INT2FIX( ~crc & 0xffff );
+
+
 }
 
 void Init_native_extensions() {
 
+  // main tdriver module
 	VALUE mTDriver = rb_define_module( "TDriver" );
 
-	VALUE mNativeExtensions = rb_define_module_under( mTDriver, "NativeExtensions" );
+  // checksum module
+	VALUE cChecksum = rb_define_class_under( mTDriver, "Checksum", rb_cObject );
+	
+	// checksum methods
+	rb_define_singleton_method( cChecksum, "crc16_ibm", crc16_ibm, -1 );
 
+  // deprecated - for backwards compatibility
+	VALUE mNativeExtensions = rb_define_module_under( mTDriver, "NativeExtensions" );
 	VALUE mCRC = rb_define_module_under( mNativeExtensions, "CRC" );
+	rb_define_singleton_method( mCRC, "crc16_ibm", crc16_ibm, -1 );
 
-	rb_define_singleton_method( mCRC, "crc16_ibm", crc16_ibm, 1 );
 
 }

data/lib/tdriver-devtools/behaviour/old/xml/example/flick-example.rb

@@ -92,31 +92,7 @@ module MobyBehaviour
     #    app.QPushButton( :text => "Close" ).flick :Left
     #
     def flick( direction, button = :Left, optional_params = {} )
-
-    begin
-          use_tap_screen = optional_params[:use_tap_screen].nil? ? MobyUtil::Parameter[ @sut.id][ :use_tap_screen, 'false'] :
-            optional_params[:use_tap_screen].to_s
-          optional_params[:useTapScreen] = use_tap_screen
-          
-          speed = calculate_speed(@sut.parameter(:gesture_flick_distance), @sut.parameter(:gesture_flick_speed))
-          distance = @sut.parameter(:gesture_flick_distance).to_i
-          params = {:gesture_type => :MouseGesture, :direction => direction, :speed => speed, :distance => distance, :isDrag => false, :button => button, :useTapScreen => use_tap_screen}
-          params.merge!(optional_params)
-     
-          do_gesture(params)    
-          do_sleep(speed)
-           
-        rescue Exception => e
-
-          MobyUtil::Logger.instance.log "behaviour" , "FAIL;Failed flick with direction \"#{direction}\", button \"#{button.to_s}\".;#{identity};flick;"
-          Kernel::raise e        
-        end      
- 
-        MobyUtil::Logger.instance.log "behaviour" , "PASS;Operation flick executed successfully with direction \"#{direction}\", button \"#{button.to_s}\".;#{identity};flick;"
-
-        nil
-      end
-
+    end
 
     private
 
@@ -126,98 +102,19 @@ module MobyBehaviour
       # gesture_type: :MouseGesture, :MouseGestureTo, :MouseGestureToCoordinates
       # params = {:direction => :Up, duration => 2, :distance =>100, :isDrag =>false, :isMove =>false }
       def do_gesture(params)
-          validate_gesture_params!(params)
-
-          if attribute('objectType') == 'Embedded'
-          params['x'] = center_x
-          params['y'] = center_y          
-          params['useCoordinates'] = 'true'
-          end
-
-        command = command_params #in qt_behaviour           
-        command.command_name(params[:gesture_type].to_s)
-        command.command_params( params )
-        @sut.execute_command( command )
       end
 
-      def validate_gesture_params!(params)
-        #direction    
-        if params[:gesture_type] == :MouseGesture
-        if params[:direction].kind_of?(Integer)
-          raise ArgumentError.new( "Invalid direction." ) unless 0 <= params[:direction].to_i and params[:direction].to_i <= 360 
-        else
-          raise ArgumentError.new( "Invalid direction." ) unless @@_valid_directions.include?(params[:direction])  
-          params[:direction] = @@_direction_map[params[:direction]]
-        end
-        #distance
-        params[:distance] = params[:distance].to_i unless params[:distance].kind_of?(Integer)
-        raise ArgumentError.new( "Distance must be an integer and greater than zero." ) unless  params[:distance] > 0
-        elsif params[:gesture_type] == :MouseGestureToCoordinates
-        raise ArgumentError.new("X and Y must be integers.") unless params[:x].kind_of?(Integer) and params[:y].kind_of?(Integer)
-        elsif params[:gesture_type] == :MouseGestureTo
-        raise ArgumentError.new("targetId and targetType must be defined.") unless params[:targetId] and params[:targetType]
-        end        
-
-        #duration/speed 
-        params[:speed] = params[:speed].to_f unless params[:speed].kind_of?(Numeric)
-        raise ArgumentError.new( "Duration must be a number and greated than zero, was:" + params[:speed].to_s) unless params[:speed] > 0
-        duration_secs = params[:speed].to_f
-        duration_secs = duration_secs*1000
-        params[:speed] = duration_secs.to_i
-
-        #mouseMove true always
-        params[:mouseMove] = true
-
-        params[:button] = :Left unless params[:button]
-        raise ArgumentError.new( "Invalid button." ) unless @@_valid_buttons.include?(params[:button])
-        params[:button] = @@_buttons_map[params[:button]]
-
-        if params[:isMove] == true
-        params[:press] = 'false'
-        params[:release] = 'false'
-        end
-
-      end
-
-
       def do_sleep(time)
-
-        if MobyUtil::Parameter[ @sut.id ][ :sleep_disabled, nil ] != 'true'
-        time = time.to_f
-        time = time * 1.3
-        #for flicks the duration of the gesture is short but animation (scroll etc..) may not
-        #so wait at least one second
-        time = 1 if time < 1  
-        sleep time
-        end
-
       end
 
       def calculate_speed(distance, speed)
-
-        distance = distance.to_f
-        speed = speed.to_f
-        duration = distance/speed
-        duration
-
       end
 
       def distance_to_point(x, y)
-
-        x = x.to_i
-        y = y.to_i
-        dist_x = x - center_x.to_i
-        dist_y = y - center_y.to_i
-
-        return 0 if dist_y == 0 and dist_x == 0     
-        distance = Math.hypot( dist_x, dist_y )
-        distance
-
       end
 
     end
 
   end
-end
 
-MobyUtil::Logger.instance.hook_methods( MobyBehaviour::QT::Gesture )
+end

data/lib/tdriver/base/behaviour/factory.rb

@@ -199,19 +199,19 @@ module MobyBase
 
     rescue MobyUtil::EmptyFilenameError
 
-    Kernel::raise EmptyFilenameError.new( "Unable to load behaviours xml file due to filename is empty or nil" )
+      raise EmptyFilenameError, "Unable to load behaviours xml file due to filename is empty or nil" 
 
-    rescue MobyUtil::FileNotFoundError => ex
+    rescue MobyUtil::FileNotFoundError
 
-    Kernel::raise ex
+      raise
 
-    rescue IOError => ex
+    rescue IOError
 
-    Kernel::raise IOError.new("Error occured while loading behaviours xml file %s. Reason: %s" % [ @file_name, ex.message ] )
+      raise IOError, "Error occured while loading behaviours xml file %s. Reason: %s" % [ @file_name, $!.message ]
 
-    rescue => ex
+    rescue
 
-    Kernel::raise RuntimeError.new( "Error occured while parsing behaviours xml file %s. Reason: %s (%s)" % [ @file_name, ex.message, ex.class ] )
+      raise RuntimeError, "Error occured while parsing behaviours xml file %s. Reason: %s (%s)" % [ @file_name, $!.message, $!.class ]
 
     end
 
@@ -223,111 +223,175 @@ module MobyBase
 
     behaviour_files.each{ | behaviours | 
 
-    begin
+      begin
 
-      # skip parsing the xml if string is empty
-      next if behaviours[ :xml ].empty?
+        # skip parsing the xml if string is empty
+        next if behaviours[ :xml ].empty?
 
-      # parse behaviour xml
-      document = MobyUtil::XML.parse_string( behaviours[ :xml ] )
+        # parse behaviour xml
+        document = MobyUtil::XML.parse_string( behaviours[ :xml ] )
 
-    rescue => exception
+      rescue
 
-      Kernel::raise MobyUtil::XML::ParseError.new( 
-                            "Error occured while parsing behaviour XML file %s. Error: %s " % [ behaviours[ :filename ], exception.message ] 
-                            ) 
+        raise MobyUtil::XML::ParseError, "Error occured while parsing behaviour XML file #{ behaviours[ :filename ] }. Error: #{ $!.message }"
 
-    end
+      end
 
-    # retrieve root attributes
-    root_attributes = document.root.xpath( "/behaviours" ).first.attributes
+      # process each behaviours element
+      document.root.xpath( "/behaviours" ).each{ | behaviours_element |
+      
+        # retrieve root attributes
+        root_attributes = behaviours_element.attributes
 
-    # parse retrieve behaviour definitions
-    document.root.xpath( "/behaviours/behaviour" ).each{ | node |
+        # process each behaviour element      
+        behaviours_element.xpath( "behaviour" ).each{ | node |
 
-      # retrieve behaviour attributes & module node
-      attributes = node.attributes
+          # retrieve behaviour attributes & module node
+          attributes = node.attributes
 
-      name = attributes[ "name" ].to_s
-      object_type = attributes[ "object_type" ].to_s
-      input_type = attributes[ "input_type" ].to_s
-      sut_type = attributes[ "sut_type" ].to_s
-      version = attributes[ "version" ].to_s
+          name = attributes[ "name" ].to_s
+          object_type = attributes[ "object_type" ].to_s
+          input_type = attributes[ "input_type" ].to_s
+          sut_type = attributes[ "sut_type" ].to_s
+          version = attributes[ "version" ].to_s
 
-      env = ( attributes[ "env" ] || '*' ).to_s 
+          env = ( attributes[ "env" ] || '*' ).to_s 
 
-      module_node = node.xpath( 'module' ).first
-      
-      name = attributes[ "name" ].to_s
-      object_type = attributes[ "object_type" ].to_s
-      input_type = attributes[ "input_type" ].to_s
-      sut_type = attributes[ "sut_type" ].to_s
-      version = attributes[ "version" ].to_s
-      
-      # verify that all required attributes and nodes are found in behaviour xml node
-      #Kernel::raise RuntimeError.new("Behaviour does not have a name, please see behaviour XML files") if name.empty?
-      name.not_empty("Behaviour element does not have name (name) attribute defined, please see behaviour XML files", RuntimeError)
-      
-      #Kernel::raise RuntimeError.new("Behaviour target object type not defined for #{ name } in XML") if object_type.empty?
-      object_type.not_empty("Behaviour element does not have target object type (object_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
+          module_node = node.xpath( 'module' ).first
+          
+          # verify that all required attributes and nodes are found in behaviour xml node
+          name.not_empty "Behaviour element does not have name (name) attribute defined, please see behaviour XML files", RuntimeError
+          
+          object_type.not_empty "Behaviour element does not have target object type (object_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError
 
-      #Kernel::raise RuntimeError.new("Behaviour target object input type not defined for #{ name } in XML") if input_type.empty?
-      input_type.not_empty("Behaviour element does not have target object input type (input_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
+          input_type.not_empty "Behaviour element does not have target object input type (input_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError
 
-      #Kernel::raise RuntimeError.new("Behaviour target object sut type not defined for #{ name } in XML") if sut_type.empty?
-      sut_type.not_empty("Behaviour element does not have target object sut type (sut_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
+          sut_type.not_empty "Behaviour element does not have target object sut type (sut_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError
 
-      #Kernel::raise RuntimeError.new("Behaviour target object sut version not defined for #{ name } in XML") if version.empty?
-      version.not_empty("Behaviour element does not have target object SUT version (version) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
+          version.not_empty "Behaviour element does not have target object SUT version (version) attribute defined, please see #{ name } in behaviour XML files", RuntimeError
 
-      #Kernel::raise RuntimeError.new("Behaviour implementation module not defined for #{ name } in XML") if module_node.nil?
-      module_node.not_nil("Behaviour does not have implementation module element defined, please see #{ name } in behaviour XML files", RuntimeError)
-      
-      # retrieve module name & implementation filename
-      module_attributes = module_node.attributes
-      module_file = module_attributes[ "file" ].to_s # optional
-      module_name = module_attributes[ "name" ].to_s 
-      
-      #Kernel::raise RuntimeError.new( "Behaviour implementation module name not defined for #{ name } in XML") if module_name.empty?
-      module_name.not_empty("Behaviour does not have implementation module name defined, please see #{ name } in behaviour XML files", RuntimeError)
+          module_node.not_nil "Behaviour does not have implementation module element defined, please see #{ name } in behaviour XML files", RuntimeError
+          
+          # retrieve module name & implementation filename
+          module_attributes = module_node.attributes
+          module_file = module_attributes[ "file" ].to_s # optional
+          module_name = module_attributes[ "name" ].to_s 
+          
+          module_name.not_empty "Behaviour does not have implementation module name defined, please see #{ name } in behaviour XML files", RuntimeError
 
-      methods_hash = {}
+          methods_hash = {}
 
-      # create hash of methods
-      node.xpath( 'methods/method' ).each{ | method |
+          # create hash of methods
+          node.xpath( 'methods/method' ).each{ | method |
 
-        # retrieve method description & example and store to methods hash
-        methods_hash[ method.attribute( "name" ).to_s.to_sym ] = {
+            # retrieve method description & example and store to methods hash
+            methods_hash[ method.attribute( "name" ).to_s.to_sym ] = {
+              :description => method.at_xpath( 'description/text()' ).to_s, 
+              :example     => method.at_xpath( 'example/text()' ).to_s
+            }
 
-          :description => method.at_xpath( 'description/text()' ).to_s, 
+          }
+
+          # create and store beahaviour hash
+          @@behaviours << {
+
+            :name => name,
+            :requires => root_attributes[ "plugin" ].to_s.split(";"),
+            :object_type => object_type.split(";"),
+            :input_type => input_type.split(";"),
+            #:sut_type => sut_type.split(";"),
+            :version => version.split(";"),
+            :env => env.split(";"),
+
+            :module => { 
+              :file => module_file, 
+              :name => module_name 
+            },
+
+            :methods => methods_hash
+
+          }
 
-          :example     => method.at_xpath( 'example/text()' ).to_s
 
         }
 
       }
 
-      # create and store beahaviour hash
-      @@behaviours << {
+=begin
 
-      :name => name,
-      :requires => root_attributes[ "plugin" ].to_s.split(";"),
-      :object_type => object_type.split(";"),
-      :input_type => input_type.split(";"),
-#      :sut_type => sut_type.split(";"),
-      :version => version.split(";"),
-      :env => env.split(";"),
+      # parse retrieve behaviour definitions
+      document.root.xpath( "/behaviours/behaviour" ).each{ | node |
 
-      :module => { 
-        :file => module_file, 
-        :name => module_name 
-      },
+        # retrieve behaviour attributes & module node
+        attributes = node.attributes
 
-      :methods => methods_hash
+        name = attributes[ "name" ].to_s
+        object_type = attributes[ "object_type" ].to_s
+        input_type = attributes[ "input_type" ].to_s
+        sut_type = attributes[ "sut_type" ].to_s
+        version = attributes[ "version" ].to_s
 
-      }
+        env = ( attributes[ "env" ] || '*' ).to_s 
 
-    }
+        module_node = node.xpath( 'module' ).first
+        
+        # verify that all required attributes and nodes are found in behaviour xml node
+        name.not_empty("Behaviour element does not have name (name) attribute defined, please see behaviour XML files", RuntimeError)
+        
+        object_type.not_empty("Behaviour element does not have target object type (object_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
+
+        input_type.not_empty("Behaviour element does not have target object input type (input_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
+
+        sut_type.not_empty("Behaviour element does not have target object sut type (sut_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
+
+        version.not_empty("Behaviour element does not have target object SUT version (version) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
+
+        module_node.not_nil("Behaviour does not have implementation module element defined, please see #{ name } in behaviour XML files", RuntimeError)
+        
+        # retrieve module name & implementation filename
+        module_attributes = module_node.attributes
+        module_file = module_attributes[ "file" ].to_s # optional
+        module_name = module_attributes[ "name" ].to_s 
+        
+        #Kernel::raise RuntimeError.new( "Behaviour implementation module name not defined for #{ name } in XML") if module_name.empty?
+        module_name.not_empty("Behaviour does not have implementation module name defined, please see #{ name } in behaviour XML files", RuntimeError)
+
+        methods_hash = {}
+
+        # create hash of methods
+        node.xpath( 'methods/method' ).each{ | method |
+
+          # retrieve method description & example and store to methods hash
+          methods_hash[ method.attribute( "name" ).to_s.to_sym ] = {
+            :description => method.at_xpath( 'description/text()' ).to_s, 
+            :example     => method.at_xpath( 'example/text()' ).to_s
+          }
+
+        }
+
+        # create and store beahaviour hash
+        @@behaviours << {
+
+          :name => name,
+          :requires => root_attributes[ "plugin" ].to_s.split(";"),
+          :object_type => object_type.split(";"),
+          :input_type => input_type.split(";"),
+         #:sut_type => sut_type.split(";"),
+          :version => version.split(";"),
+          :env => env.split(";"),
+
+          :module => { 
+            :file => module_file, 
+            :name => module_name 
+          },
+
+          :methods => methods_hash
+
+        }
+
+      }
+      
+=end
 
     }
 
@@ -413,20 +477,21 @@ module MobyBase
 
   end
 
-
   def get_behaviour_from_cache( target, sut_type, object_type, sut_version, input_type )
 
     if @_behaviour_cache.has_key?( object_type )
 
-    # apply modules to target object
-    @_behaviour_cache[ object_type ].each{ | module_name | target.instance_eval( "self.extend(#{ module_name })" ) }
+      # apply modules to target object
+      @_behaviour_cache[ object_type ].each{ | module_name | target.instance_eval( "self.extend(#{ module_name })" ) }
 
-    # return true
-    true
+      # return true
+      true
 
     else
-    # return false
-    false
+    
+      # return false
+      false
+      
     end
 
   end