testability-driver-qt-sut-plugin 1.2.1 → 1.3.0

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/controllers/key_sequence.rb

@@ -19,92 +19,75 @@
 
 module MobyController
 
-	module QT
+  module QT
 
-		module KeySequence
+    module KeySequence
 
-			def set_adapter( adapter )
+      include MobyController::Abstraction
 
-				@sut_adapter = adapter
+      # Creates service command message which will be sent to @sut_adapter by execute method
+      # == params         
+      # == returns
+      # == raises
+      def make_message
 
-			end
+        press_types = { :KeyDown => 'KeyPress', :KeyUp => 'KeyRelease' }
 
-			# Execute the command(s). Iterated trough the @message_array and sends all
-			# message to the device using the @sut_adapter (see base class)     
-			# == params      
-			# == returns
-			# == raises
-			# RuntimeError: No service request to be sent due to key sequence is empty
-			def execute
+        sut = @_sut
 
-				@sut_adapter.send_service_request( 
+        keymap = $parameters[ sut.id ][ :keymap ]
 
-          Comms::MessageGenerator.generate( make_message ) 
+        sequence = @sequence
+        
+        message = Nokogiri::XML::Builder.new{
 
-        )
+          TasCommands( :id => sut.application.id, :transitions => 'true', :service => 'uiCommand' ){
 
-			end
+            Target( :TasId => 'FOCUSWIDGET', :type => 'Standard' ){
 
-			private
-			#
-			# Internal message generation method. Makes xml messages from the command_data     
-			# == params      
-			# none
-			def make_message
+              sequence.each{ | key_press |
 
-				press_types = { :KeyDown => 'KeyPress', :KeyUp => 'KeyRelease' }
+                key_press[ :value ].tap{ | key |
 
-				sut = @_sut
+                  # raise exception if value type other than Fixnum or Symbol
+                  raise ArgumentError, "Wrong argument type #{ key.class } for key (expected: Symbol or Fixnum)" unless [ Fixnum, Symbol ].include?( key.class ) 
 
-				sequence = @sequence
-
-				message = Nokogiri::XML::Builder.new{
-
-					TasCommands( :id => sut.application.id, :transitions => 'true', :service => 'uiCommand' ){
-
-						Target( :TasId => 'FOCUSWIDGET', :type => 'Standard' ){
-
-							sequence.each{ | key_press |
-
-								key_press[ :value ].tap{ | key |
-
-									# raise exception if value type other than Fixnum or Symbol
-									Kernel::raise ArgumentError.new( "Wrong argument type %s for key (Expected: %s)" % [ key.class, "Symbol/Fixnum" ] ) unless [ Fixnum, Symbol ].include?( key.class ) 
-
-									# verify that keymap is defined for sut if symbol used. 
-									Kernel::raise ArgumentError.new("Symbol #{ key.inspect } cannot be used due to no keymap defined for #{ sut.id } in TDriver configuration file.") if key.kind_of?( Symbol ) && $parameters[ sut.id ][ :keymap ].nil?
+                  # verify that keymap is defined for sut if symbol used. 
+                  raise ArgumentError, "Symbol #{ key.inspect } cannot be used due to no keymap defined for #{ sut.id } in TDriver configuration file." if key.kind_of?( Symbol ) && keymap.nil?
 
                   # fetch keycode from keymap
-      					  key = TDriver::KeymapUtilities.fetch_keycode( key, $parameters[ sut.id ][ :keymap ] )
+                  key = TDriver::KeymapUtilities.fetch_keycode( key, keymap )
 
-									# retrieve corresponding scan code (type of string, convert to fixnum) for symbol from keymap if available 
-									key = key.hex if key.kind_of?( String )
+                  # retrieve corresponding scan code (type of string, convert to fixnum) for symbol from keymap if available 
+                  key = key.hex if key.kind_of?( String )
 
-									# raise exception if value is other than fixnum
-									Kernel::raise ArgumentError.new( "Scan code for :%s not defined in keymap" % key ) unless key.kind_of?( Fixnum )
-		
-									# determine keypress type
-									press_type = press_types.fetch( key_press[ :type ], 'KeyClick' )
+                  # raise exception if value is other than fixnum
+                  raise ArgumentError, "Scan code for #{ key.inspect } not defined in keymap" unless key.kind_of?( Fixnum )
+    
+                  # determine keypress type
+                  press_type = press_types.fetch( key_press[ :type ], 'KeyClick' )
 
-									Command( key.to_s, "name" => press_type.to_s, "modifiers" => "0", "delay" => "0")
+                  Command( key.to_s, "name" => press_type.to_s, "modifiers" => "0", "delay" => "0")
 
-								}
+                }
 
-							}
+              }
 
-						}
-					}
-				}.to_xml
+            }
+            
+          }
+          
+        }.to_xml
 
-				message
+        Comms::MessageGenerator.generate( message )
 
-			end
+      end
 
-			# enable hooking for performance measurement & debug logging
-			TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+      # enable hooking for performance measurement & debug logging
+      TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
-		end # KeySequence
+    end # KeySequence
 
-	end # QT
+  end # QT
 
 end # MobyController

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/controllers/screen_capture.rb

@@ -19,36 +19,35 @@
 
 module MobyController
 
-	module QT
+  module QT
 
-		module ScreenCapture 
+    module ScreenCapture 
 
-			def set_adapter( adapter )      
-				@sut_adapter = adapter
-			end
+      include MobyController::Abstraction
 
-			def execute
+      # Creates service command message which will be sent to @sut_adapter by execute method
+      # == params         
+      # == returns
+      # == raises
+      def make_message
 
-				@sut_adapter.send_service_request(
-					Comms::MessageGenerator.generate(
-						Nokogiri::XML::Builder.new{
-							TasCommands( :id=> 1, :service => "screenShot" ) {
-								Target( :TasId => 1, :type => "Application" ) {
-									Command( :name => "Screenshot", :format => @context.image_mime_type, :draw => @context.redraw.to_s )
-								}
-							}
-						}.to_xml
-					)
-				)
+        Comms::MessageGenerator.generate(
+          Nokogiri::XML::Builder.new{
+            TasCommands( :id=> 1, :service => "screenShot" ) {
+              Target( :TasId => 1, :type => "Application" ) {
+                Command( :name => "Screenshot", :format => @context.image_mime_type, :draw => @context.redraw.to_s )
+              }
+            }
+          }.to_xml
+        )
 
-			end
+      end
 
-			# enable hooking for performance measurement & debug logging
-			TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+      # enable hooking for performance measurement & debug logging
+      TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
+    end # ScreenCapture
 
-		end # ScreenCapture
-
-	end # QT
+  end # QT
 
 end # MobyController

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/controllers/tap.rb

@@ -19,33 +19,44 @@
 
 module MobyController
 
-	module QT
-
-		module Tap 
-
-			def set_adapter( adapter )      
-				@sut_adapter = adapter
-			end
-
-			def execute
-
-				command_xml = Nokogiri::XML::Builder.new{
-				  TasCommands( :service => "uiCommand" ) {
-				    Target( :TasId => 1, :type => "Application" ) {
-				      Command( :name => "TapScreen", :x => get_x, :y => get_y, :button => 1, :count => 1, :mouseMove => true, :useCoordinates => true, :time_to_hold => get_hold )
-				    }
-				  }
-				}.to_xml
-
-				@sut_adapter.send_service_request(Comms::MessageGenerator.generate(command_xml))
-
-			end
-
-			# enable hooking for performance measurement & debug logging
-			TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
-
-		end # Tap
-
-	end # QT
+  module QT
+
+    module Tap 
+
+      include MobyController::Abstraction
+
+      # Creates service command message which will be sent to @sut_adapter by execute method
+      # == params         
+      # == returns
+      # == raises
+      def make_message
+
+        Comms::MessageGenerator.generate(
+          Nokogiri::XML::Builder.new{
+            TasCommands( :service => "uiCommand" ) {
+              Target( :TasId => 1, :type => "Application" ) {
+                Command( 
+                  :name => "TapScreen", 
+                  :x => get_x, 
+                  :y => get_y, 
+                  :button => 1, 
+                  :count => 1, 
+                  :mouseMove => true, 
+                  :useCoordinates => true, 
+                  :time_to_hold => get_hold 
+                )
+              }
+            }
+          }.to_xml
+        )
+
+      end
+
+      # enable hooking for performance measurement & debug logging
+      TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+
+    end # Tap
+
+  end # QT
 
 end # MobyController

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/controllers/version.rb

@@ -21,36 +21,26 @@ module MobyController
 
   module QT
 
-	  module VersionCommand
+    module VersionCommand
 
-	    # Execute the command
-	    # Sends the message to the device using the @sut_adapter (see base class)     
-	    # == params         
-	    # == returns
-	    # == raises
-	    # NotImplementedError: raised if unsupported command type       
-	    def execute
+      include MobyController::Abstraction
 
-        # TODO: message contructed with builder 
-		    @sut_adapter.send_service_request(
+      # Creates service command message which will be sent to @sut_adapter by execute method
+      # == params         
+      # == returns
+      # == raises
+      def make_message
 
-          MobyController::QT::Comms::MessageGenerator.generate( "<TasCommands service=\"versionService\" />" ), false
+        # *[ message, return_crc ]
+        [ Comms::MessageGenerator.generate( "<TasCommands service=\"versionService\" />" ), false ]
 
-        )
+      end
 
-	    end
+      # enable hooking for performance measurement & debug logging
+      TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
-	    def set_adapter( adapter )
-
-  		  @sut_adapter = adapter
-
-	    end
-
-	    # enable hooking for performance measurement & debug logging
-	    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
-
-	  end # VersionCommand
-	
+    end # VersionCommand
+  
   end # QT
 
 end # MobyController

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/controllers/widget.rb

@@ -17,72 +17,69 @@
 ## 
 ############################################################################
 
-
-
 module MobyController
 
-	module QT
+  module QT
 
-		module WidgetCommand 
+    module WidgetCommand 
 
-			# Execute the command). 
-			# Sends the message to the device using the @sut_adapter (see base class)     
-			# == params         
-			# == returns
-			# == raises
-			# NotImplementedError: raised if unsupported command type       
-			def execute
+      # Execute the command). 
+      # Sends the message to the device using the @sut_adapter (see base class)     
+      # == params         
+      # == returns
+      # == raises
+      # NotImplementedError: raised if unsupported command type       
+      def execute
 
-			  command_params = { :eventType => get_event_type, :name => get_command_name }
+        command_params = { :eventType => get_event_type, :name => get_command_name }
 
-			  command_params.merge!( get_command_params ) if get_command_params
+        command_params.merge!( get_command_params ) if get_command_params
 
-			  builder = Nokogiri::XML::Builder.new{
+        builder = Nokogiri::XML::Builder.new{
 
-				  TasCommands( :id => get_application_id, :transitions => get_transitions, :service => get_service || 'uiCommand' ) {
+          TasCommands( :id => get_application_id, :transitions => get_transitions, :service => get_service || 'uiCommand' ) {
 
-				    Target( :TasId => get_object_id, :type => get_object_type ) {
+            Target( :TasId => get_object_id, :type => get_object_type ) {
 
-					  if get_command_value.kind_of?( Array )
+            if get_command_value.kind_of?( Array )
 
-					    get_command_value.each do | command_part |
-						    Command( command_part[ :value ], command_part[ :params ] )
-					    end
+              get_command_value.each do | command_part |
+                Command( command_part[ :value ], command_part[ :params ] )
+              end
 
             elsif get_command_value
 
-  					    Command( get_command_value, command_params )
-
-					  else
+                Command( get_command_value, command_params )
 
-  					    Command( command_params )
+            else
 
-					  end
+                Command( command_params )
 
-				    }
-				  }
-			  }						  
+            end
 
-			  if @sut_adapter.group?
-  				@sut_adapter.append_command( builder.doc.root.children )
-			  else
-	  			@sut_adapter.send_service_request( Comms::MessageGenerator.generate( builder.to_xml ) )
-			  end
+            }
+          }
+        }              
 
-			end
+        if @sut_adapter.group?
+          @sut_adapter.append_command( builder.doc.root.children )
+        else
+          @sut_adapter.send_service_request( Comms::MessageGenerator.generate( builder.to_xml ) )
+        end
 
-			def set_adapter( adapter )
+      end
 
-				@sut_adapter = adapter
+      def set_adapter( adapter )
 
-			end
+        @sut_adapter = adapter
 
-			# enable hooking for performance measurement & debug logging
-			TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
+      end
 
+      # enable hooking for performance measurement & debug logging
+      TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
-		end #module Action
+    end # WidgetCommand 
 
-	end #module QT
+  end # QT
 
-end #module MobyController
+end # MobyController

data/lib/testability-driver-plugins/testability-driver-qt-sut-plugin/sut/adapter.rb

@@ -34,7 +34,9 @@ module MobyController
 
       attr_accessor(
         :socket_read_timeout,
-        :socket_write_timeout
+        :socket_write_timeout,
+        :deflate_service_request,
+        :defalte_minimum_size
       )
       
       # TODO: better way to set the host and port parameters   
@@ -47,41 +49,70 @@ module MobyController
       # sut_id id for the sut so that client details can be fetched from params
       def initialize( sut_id, receive_timeout = 25, send_timeout = 25 )
 
+        # reset socket
         @socket = nil
+
+        # connection state is false by default
         @connected = false
 
+        # store sut id
+        @sut_id = sut_id
+
+        # reset hooks - no hooks by default
+        @hooks = {}
+
+        # reset sent/received bytes and packets counters
         @socket_received_bytes = 0
         @socket_sent_bytes = 0
 
         @socket_received_packets = 0
         @socket_sent_packets = 0
 
-        @sut_id = sut_id
-
         # set timeouts
         @socket_read_timeout = receive_timeout
         @socket_write_timeout = send_timeout
 
+        # randomized value for initial message packet counter
         @counter = rand( 1000 )
 
+        # optimization - use local variables for less AST lookups
+        @tcp_socket_select_method = TCPSocket.method( :select )
+
+        @tdriver_checksum_crc16_ibm_method = TDriver::Checksum.method( :crc16_ibm )
+
+        # retrieve sut configuration
+        _sut_parameters = $parameters[ @sut_id ]
+
         # determine which inflate method to use
-        if $parameters[ @sut_id ][ :win_native, false ].to_s == "true"
+        if _sut_parameters[ :win_native, false ].to_s.true?
+
+          @zlib_inflate_method = Zlib::Inflate.new( -Zlib::MAX_WBITS ).method( :inflate )
 
           @inflate_method = method( :inflate_windows_native )
 
         else
 
+          @zlib_inflate_method = Zlib::Inflate.method( :inflate )
+
           @inflate_method = method( :inflate )
 
         end
 
-        @hooks = {}
+        # default size 1kb
+        @deflate_minimum_size = _sut_parameters[ :io_deflate_minimum_size_in_bytes, 1024 ].to_i
+
+        # enabled by default - deflate outgoing service request if size > deflate_minimum_size
+        @deflate_service_request = _sut_parameters[ :io_deflate_service_request, true ].true? 
+
+        # retrieve default compression level - best compression by default
+        @deflate_compression_level = _sut_parameters[ :io_deflate_compression_level, 9 ].to_i
 
       end
 
       # TODO: document me
       def disconnect
 
+        # disconnect socket only if connected
         @socket.close if @connected
 
         @connected = false
@@ -144,11 +175,11 @@ module MobyController
       end
 
       # TODO: document me
-      def append_command(node_list)
+      def append_command( node_list )
 
-        node_list.each { | ch | 
+        node_list.each { | child | 
 
-          @_builder.doc.root.add_child( ch ) 
+          @_builder.doc.root.add_child( child )
 
         }
 
@@ -188,7 +219,15 @@ module MobyController
       # message:: message in qttas protocol format   
       # == returns    
       # the response body
-      def send_service_request( message, return_crc = false )
+      def send_service_request( message, return_checksum = false )
+
+        read_message_id = 0
+
+        header = nil
+
+        body = nil
+
+        crc = nil
 
         connect if !@connected
 
@@ -198,35 +237,35 @@ module MobyController
         # set request message id
         message.message_id = @counter
 
+        # deflate message body
+        if @deflate_service_request == true
+
+          # do not deflate messages below 1kb
+          message.deflate( @deflate_compression_level ) unless message.size < @deflate_minimum_size
+
+        end
+
         # generate binary message to be sent to socket
         binary_message = message.make_binary_message( @counter )
 
         # write request message to socket
         write_socket( binary_message )
 
-        # read response to determine was the message handled properly and parse the header
-        # header[ 0 ] = command_flag
-        # header[ 1 ] = body_size
-        # header[ 2 ] = crc
-        # header[ 3 ] = compression_flag
-        # header[ 4 ] = message_id
-
-        read_message_id = 0
-
-        header = nil
-
-        body = nil
-
         until read_message_id == @counter
         
           # read message header from socket, unpack string to array
+          # header[ 0 ] = command_flag
+          # header[ 1 ] = body_size
+          # header[ 2 ] = crc
+          # header[ 3 ] = compression_flag
+          # header[ 4 ] = message_id
           header = read_socket( 12 ).unpack( 'CISCI' )
 
           # read message body from socket
           body = read_socket( header[ 1 ] )
 
           # calculate body crc16 checksum
-          crc = TDriver::Checksum.crc16_ibm( body )
+          crc = @tdriver_checksum_crc16_ibm_method.call( body )
 
           # read the message body and compare crc checksum
           raise IOError, "CRC checksum did not match, response message body is corrupted! (#{ crc } != #{ header[ 2 ] })" if crc != header[ 2 ]
@@ -274,26 +313,44 @@ module MobyController
 
         end
 
-        # return the body ( and crc if required )
-        return_crc ? [ body, header[ 2 ] ] : body
+        # return the body and checksum if required
+        return_checksum ? [ body, body.hash ] : body
 
       end
 
     private
 
+      # TODO: document me
+      def wait_for_data_available( bytes_count )
+
+        # verify that there is data available to be read 
+        raise IOError, "Socket reading timeout (#{ @socket_read_timeout.to_i }) exceeded for #{ bytes_count.to_i } bytes" if @tcp_socket_select_method.call( [ @socket ], nil, nil, @socket_read_timeout ).nil?
+
+      end
+
+      def wait_for_data_sent( bytes_count )
+
+        # verify that there is no data in writing buffer 
+        raise IOError, "Socket writing timeout (#{ @socket_write_timeout.to_i }) exceeded for #{ bytes_count.to_i } bytes" if @tcp_socket_select_method.call( nil, [ @socket ], nil, @socket_write_timeout ).nil?
+
+      end
+
       # TODO: document me
       def read_socket( bytes_count )
 
+        # use local variables, performing less ATS (Abstract Syntax Tree) calls
+        _socket_read_timeout = @socket_read_timeout
+
         # store time before start receving data
         start_time = Time.now
 
         # verify that there is data available to be read 
-        raise IOError, "Socket reading timeout (#{ @socket_read_timeout.to_i }) exceeded for #{ bytes_count.to_i } bytes" if TCPSocket::select( [ @socket ], nil, nil, @socket_read_timeout ).nil?
+        wait_for_data_available( bytes_count )
 
         # read data from socket
         read_buffer = @socket.read( bytes_count ){
 
-          raise IOError, "Socket reading timeout (#{ @socket_read_timeout.to_i }) exceeded for #{ bytes_count.to_i } bytes" if ( Time.now - start_time ) > @socket_read_timeout
+          raise IOError, "Socket reading timeout (#{ _socket_read_timeout.to_i }) exceeded for #{ bytes_count.to_i } bytes" if ( Time.now - start_time ) > _socket_read_timeout
 
         }
 
@@ -305,106 +362,20 @@ module MobyController
         @socket_received_packets += 1
 
         read_buffer
-        
-=begin
-        begin
-
-          read_buffer = @socket.read_nonblock( bytes_count )
-
-        rescue Errno::EWOULDBLOCK
-
-          if TCPSocket.select( [ @socket ], nil, nil, @socket_read_timeout )
-
-            read_buffer = @socket.read_nonblock( bytes_count )
-
-          else
-
-            Kernel::raise IOError.new( "Socket reading timeout (%i) exceeded for %i bytes" % [ @socket_read_timeout, bytes_count ] )
-
-          end
-
-        end
-
-        read_buffer
-=end
-
-=begin
-        #Kernel::raise ThreadError, "Timeout within critical session" if Thread.critical
-
-        begin
-
-          # store current thread
-          main_thread = Thread.current
-
-          # create timeout thread
-          timeout_thread = Thread.new( @socket_read_timeout ){ | timeout, bytes_count |
-
-            # sleep the timeout
-            sleep time
-
-            # raise exception if timeout exceeds
-            main_thread.raise IOError.new( "Socket reading timeout (%i) exceeded for %i bytes" % [ timeout, bytes_count ] ) if main_thread.alive?
-
-          }
-          
-          # read data from socket          
-          @socket.read( bytes_count )
-
-        ensure
-
-          # ensure that timeout thread is terminated
-          timeout_thread.kill if timeout_thread && timeout_thread.alive?
-
-          @socket_received_bytes += bytes_count 
-
-        end
-=end
 
       end
 
       # TODO: document me
       def write_socket( data )
 
-        @socket_sent_bytes += data.size
-
-        @socket_sent_packets += 1
-
         @socket.write( data )
 
         # verify that there is no data in writing buffer 
-        raise IOError, "Socket writing timeout (#{ @socket_write_timeout.to_i }) exceeded for #{ data.length.to_i } bytes" if TCPSocket::select( nil, [ @socket ], nil, @socket_write_timeout ).nil?
+        wait_for_data_sent( data.length )
  
-=begin
-
-        begin
-          
-          # store current thread
-          main_thread = Thread.current
-
-          # create timeout thread
-          timeout_thread = Thread.new( @socket_write_timeout ){ | timeout, data.size |
-
-            # sleep the timeout
-            sleep time
-
-            # raise exception if timeout exceeds
-            main_thread.raise IOError.new( "Socket writing timeout (%i) exceeded for %i bytes" % [ timeout, bytes_count ] ) if main_thread.alive?
-
-          }
-
-          # read data from socket          
-          @socket.write( data )
-
-        ensure
-
-          # ensure that timeout thread is terminated
-          timeout_thread.kill if timeout_thread and timeout_thread.alive?
-
-          @socket_sent_bytes += data.size
-
-        end
+        @socket_sent_bytes += data.size
 
-=end
+        @socket_sent_packets += 1
 
       end
 
@@ -413,13 +384,15 @@ module MobyController
       # inflate to be used in native windows env.
       def inflate_windows_native( body )
 
-        unless body.empty?
+        tmp = body
 
-          Zlib::Inflate.new( -Zlib::MAX_WBITS ).inflate( body )
+        unless tmp.empty?
+
+          @zlib_inflate_method.call( tmp )
 
         else  
 
-          body
+          tmp
 
         end 
 
@@ -433,7 +406,7 @@ module MobyController
 
         unless tmp.empty?
 
-          Zlib::Inflate.inflate( tmp )
+          @zlib_inflate_method.call( tmp )
 
         else