testability-driver-qt-sut-plugin 1.1.1 → 1.2.0

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

@@ -0,0 +1,56 @@
+############################################################################
+## 
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
+## All rights reserved. 
+## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
+## 
+## This file is part of TDriver. 
+## 
+## 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 MobyController
+
+  module QT
+
+	  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
+
+        # TODO: message contructed with builder 
+		    @sut_adapter.send_service_request(
+
+          MobyController::QT::Comms::MessageGenerator.generate( "<TasCommands service=\"versionService\" />" ), false
+
+        )
+
+	    end
+
+	    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 # QT
+
+end # MobyController

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

@@ -100,29 +100,37 @@ module MobyPlugin
 			# returns SUT object - this method will be called from MobyBase::SUTFactory
 			def self.make_sut( sut_id )
 
-        # create sut object
-				MobyBase::SUT.new(
+        # retrieve sut specific parameters
+        sut_parameters = $parameters[ sut_id ]
 
-          # create controller for sut
-					MobyBase::SutController.new( 
+        # create sut adapter
+        adapter = MobyController::QT::SutAdapter.new( 
+
+          # sut id
+          sut_id,
+
+          # tcp/ip read timeouts, default: 15 (seconds) 
+          $parameters[ sut_id ][ :socket_read_timeout,  "15" ].to_i,
+
+          # tcp/ip write timeouts, default: 15 (seconds)
+          $parameters[ sut_id ][ :socket_write_timeout, "15" ].to_i
+
+        )
 
-            # controller id
-            "QT", 
+          # create controller for sut
+				sut_controller = MobyBase::SutController.new( 
 
-            # create sut adapter
-            MobyController::QT::SutAdapter.new( 
+          # controller id
+          "QT", 
 
-              # sut id
-              sut_id,
+          adapter
 
-      				# tcp/ip read timeouts, default: 15 (seconds) 
-              $parameters[ sut_id ][ :socket_read_timeout,  "15" ].to_i,
+        )
 
-      				# tcp/ip write timeouts, default: 15 (seconds)
-              $parameters[ sut_id ][ :socket_write_timeout, "15" ].to_i
-            )
+        # create sut object
+				sut = MobyBase::SUT.new(
 
-          ), 
+          sut_controller,
 
           # pass test object factory class
 					MobyBase::TestObjectFactory.instance,
@@ -131,6 +139,46 @@ module MobyPlugin
 					sut_id 
 				)
 
+        # hook connect method
+        adapter.add_hook( 'before_connect' ){}
+
+        # hook connect method
+        adapter.add_hook( 'after_connect' ){
+
+          begin
+
+            # send service request for agent version number
+            agent_version = sut_controller.__send__( :execute_command, MobyCommand::VersionCommand.new )
+
+            case agent_version
+
+              when "1.3"
+
+                # use optimized XML format; if adapter is not found we're going through rescue block
+                adapter = TDriver::OptimizedXML::TestObjectAdapter
+
+            else
+
+              # didn't recognize the version number use old TDriver::TestObjectAdapter
+              raise
+
+            end
+
+          rescue
+
+            # in case of any exceptions use TDriver::TestObjectAdapter with old XML format
+            adapter = TDriver::TestObjectAdapter
+
+          end
+
+          #sut_controller.test_object_adapter = adapter
+          sut.instance_variable_set( :@test_object_adapter, adapter )
+
+        }
+
+        # return sut object as result
+        sut
+
 			end
 
 			# enable hooking for performance measurement & debug logging

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

@@ -62,14 +62,31 @@ module MobyController
         @socket_read_timeout = receive_timeout
         @socket_write_timeout = send_timeout
 
-
         @counter = rand( 1000 )
 
-        # connect socket
-        #connect( @sut_id )
+        # determine which inflate method to use
+        if $parameters[ @sut_id ][ :win_native, false ].to_s == "true"
+
+          @inflate_method = method( :inflate_windows_native )
+
+        else
+
+          @inflate_method = method( :inflate )
+
+        end
+
+        @hooks = {}
 
       end
 
+      def add_hook( id, &block )
+
+        raise ArgumentError, 'Unable to add hook due to no block was given' unless block_given?
+
+        @hooks[ id ] = block
+
+      end
+  
       # TODO: document me
       def disconnect
 
@@ -84,19 +101,37 @@ module MobyController
 
         id ||= @sut_id
 
+        sut_parameters = $parameters[ id, {} ]
+
         begin
 
-          @socket = TCPSocket.open( $parameters[ id ][ :qttas_server_ip ], $parameters[ id ][ :qttas_server_port ].to_i )
+          # retrieve ip and verify that value is not empty or nil
+          ip = sut_parameters[ :qttas_server_ip, nil ].not_blank( 'Connection failure; QTTAS server IP not defined in SUT configuration' ).to_s
+
+          # retrieve port and verify that value is not empty or nil
+          port = sut_parameters[ :qttas_server_port, nil ].not_blank( 'Connection failure; QTTAS server port not defined in SUT configuration' ).to_i
+
+          # executes the code block before openning the connection
+          execute_hook( 'before_connect', id, ip, port ) if hooked?( 'before_connect' ) 
+
+          # open tcp/ip connection
+          @socket = TCPSocket.open( ip, port )
+
+          # set connected status to true
+          @connected = true
+
+          # communication authentication etc can be done here
+          execute_hook( 'after_connect', id, ip, port, @socket ) if hooked?( 'after_connect' ) 
 
-        rescue => ex
+        rescue
 
-          ip = "no ip" if ( ip = $parameters[ id ][ :qttas_server_ip, "" ] ).empty?
-          port = "no port" if ( port = $parameters[ id ][ :qttas_server_port, "" ] ).empty?
+          execute_hook( 'connection_failed', id, ip, port, $! ) if hooked?( 'connection_failed' ) 
+
+          raise IOError, "Connection failure; verify that QTTAS server is up and running at #{ ip }:#{ port }.\n Nested exception: #{ $!.message }"
 
-          Kernel::raise IOError.new("Unable to connect QTTAS server, verify that it is running properly (#{ ip }:#{ port }): .\nException: #{ ex.message }")
         end
 
-        @connected = true
+        true
 
       end
 
@@ -108,7 +143,7 @@ module MobyController
       end
 
       # Set the document builder for the grouped behaviour message.
-      def set_message_builder(builder)
+      def set_message_builder( builder )
 
         @_group = true
 
@@ -119,7 +154,11 @@ module MobyController
       # TODO: document me
       def append_command(node_list)
 
-        node_list.each {|ch| @_builder.doc.root.add_child(ch)}          
+        node_list.each { | ch | 
+
+          @_builder.doc.root.add_child( ch ) 
+
+        }
 
       end
 
@@ -133,7 +172,11 @@ module MobyController
 
         size = @_builder.doc.root.children.size
 
-        send_service_request(Comms::MessageGenerator.generate(@_builder.to_xml))
+        send_service_request(
+
+          Comms::MessageGenerator.generate( @_builder.to_xml )
+
+        )
 
         @_builder = nil
 
@@ -141,6 +184,12 @@ module MobyController
 
       end
 
+      def connected?
+
+        @connected
+
+      end
+
       # Send the message to the qt server         
       # If there is no exception propagated the send to the device was successful
       # == params   
@@ -149,13 +198,19 @@ module MobyController
       # the response body
       def send_service_request( message, return_crc = false )
 
-        connect if !@connected        
+        connect if !@connected
+
+        # increase message count
+        @counter += 1
 
         # set request message id
-        message.message_id = ( @counter += 1 )
+        message.message_id = @counter
+
+        # generate binary message to be sent to socket
+        binary_message = message.make_binary_message( @counter )
 
         # write request message to socket
-        write_socket( message.make_binary_message( @counter ) )
+        write_socket( binary_message )
 
         # read response to determine was the message handled properly and parse the header
         # header[ 0 ] = command_flag
@@ -164,20 +219,25 @@ module MobyController
         # header[ 3 ] = compression_flag
         # header[ 4 ] = message_id
 
+        read_message_id = 0
+
         header = nil
 
         body = nil
 
-        read_message_id = 0
-
         until read_message_id == @counter
         
+          # read message header from socket, unpack string to array
           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 )
+
           # read the message body and compare crc checksum
-          Kernel::raise IOError, "CRC do not match, response message body may be corrupted!" if CRC::Crc16.crc16_ibm( body, 0xffff ) != header[ 2 ]
+          raise IOError, "CRC checksum did not match, response message body is corrupted! (#{ crc } != #{ header[ 2 ] })" if crc != header[ 2 ]
           
           # validate response message; check that response message id matches the request
           # if smaller than expected try to read the next message but if bigger raise error
@@ -185,34 +245,23 @@ module MobyController
 
           if read_message_id < @counter
 
-            $logger.log "warning", "Response to request did not match: \"#{ header[ 4 ].to_s }\"<\"#{ @counter.to_s }\""
+            $logger.warning "Response to request did not match: \"#{ header[ 4 ].to_s }\"<\"#{ @counter.to_s }\""
 
           elsif read_message_id > @counter
 
-            $logger.log "fatal", "Response to request did not match: \"#{ header[ 4 ].to_s }\">\"#{ @counter.to_s }\""
+            $logger.fatal "Response to request did not match: \"#{ header[ 4 ].to_s }\">\"#{ @counter.to_s }\""
 
             # save to file?
-            $logger.log "fatal", body
+            $logger.fatal body
 
-            Kernel::raise RuntimeError.new( "Response to request did not match: \"#{ header[ 4 ].to_s }\"!=\"#{ @counter.to_s }\"" )
+            raise RuntimeError, "Response to request did not match: \"#{ header[ 4 ].to_s }\"!=\"#{ @counter.to_s }\""
 
           end
           
         end
       
         # inflate the message body if compressed
-        if ( header[ 3 ] == 2 )
-
-		  if $parameters[ @sut_id ][ :win_native, false ] == "true"
-			zstream = Zlib::Inflate.new(-Zlib::MAX_WBITS)			
-			body = zstream.inflate(body) unless body.empty?
-		  else
-			# remove leading 4 bytes		  
-			body = body[ 4 .. -1 ] 
-			body = Zlib::Inflate.inflate( body ) unless body.empty?
-		  end
-
-        end
+        body = @inflate_method.call( body ) if ( header[ 3 ] == 2 )
 
         # raise exception if messages error flag is set
         # Flag statuses:
@@ -223,11 +272,11 @@ module MobyController
 
           if body =~ /The application with Id \d+ is no longer available/
 
-            Kernel::raise MobyBase::ApplicationNotAvailableError, body
+            raise MobyBase::ApplicationNotAvailableError, body
 
           else
 
-            Kernel::raise RuntimeError, body
+            raise RuntimeError, body
 
           end
 
@@ -240,6 +289,20 @@ module MobyController
 
     private
 
+      # TODO: document me
+      def execute_hook( id, *arguments )
+
+        @hooks[ id ].call( *arguments )
+
+      end
+
+      # TODO: document me
+      def hooked? ( id )
+
+        @hooks.has_key?( id )
+
+      end
+
       # TODO: document me
       def read_socket( bytes_count )
 
@@ -247,17 +310,17 @@ module MobyController
         start_time = Time.now
 
         # verify that there is data available to be read 
-        Kernel::raise IOError.new( "Socket reading timeout (%i) exceeded for %i bytes" % [ @socket_read_timeout, bytes_count ] ) if TCPSocket::select( [ @socket ], nil, nil, @socket_read_timeout ).nil?
+        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?
 
         # read data from socket
         read_buffer = @socket.read( bytes_count ){
 
-          Kernel::raise IOError.new( "Socket reading timeout (%i) exceeded for %i bytes" % [ @socket_read_timeout, bytes_count ] ) 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
 
         }
 
         # useless?
-        Kernel::raise IOError.new( "Socket reading error for %i bytes - No data retrieved" % [ bytes_count ] ) if read_buffer.nil?
+        raise IOError, "Socket reading error for #{ bytes_count.to_i } bytes - No data retrieved" if read_buffer.nil?
 
         @socket_received_bytes += read_buffer.size
 
@@ -331,7 +394,7 @@ module MobyController
         @socket.write( data )
 
         # verify that there is no data in writing buffer 
-        Kernel::raise IOError.new( "Socket writing timeout (%i) exceeded for %i bytes" % [ @socket_write_timeout, data.length ] ) if TCPSocket::select( nil, [ @socket ], nil, @socket_write_timeout ).nil?
+        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?
  
 =begin
 
@@ -367,6 +430,41 @@ module MobyController
 
       end
 
+    private
+
+      # inflate to be used in native windows env.
+      def inflate_windows_native( body )
+
+        unless body.empty?
+
+          Zlib::Inflate.new( -Zlib::MAX_WBITS ).inflate( body )
+
+        else  
+
+          body
+
+        end 
+
+      end
+
+      # inflate to be used by default
+      def inflate( body )
+
+        # remove leading 4 bytes
+        tmp = body[ 4 .. -1 ]
+
+        unless tmp.empty?
+
+          Zlib::Inflate.inflate( tmp )
+
+        else
+
+          tmp
+
+        end
+
+      end
+
       # enable hooking for performance measurement & debug logging
       TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )