testability-driver-qt-sut-plugin 0.9.2 → 1.0.0

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

@@ -23,6 +23,8 @@ module MobyController
 	
 	module Application 
 	  
+      include MobyUtil::MessageComposer
+
 	  def set_adapter( adapter )
 		
 		@sut_adapter = adapter
@@ -56,11 +58,11 @@ module MobyController
 		  # close qttas
 		elsif @_command == :CloseQttas
 		  #params = {'uid' => '0'}
-		  command_xml = make_message({:service => 'closeApplication'},'Close',{'uid' => '0'})
+		  command_xml = make_xml_message({:service => 'closeApplication'},'Close',{'uid' => '0'})
 
 		  # kill application
 		elsif @_command == :Kill
-		  command_xml = make_message({:service => 'closeApplication'},'Kill',{'uid' => @_application_uid})
+		  command_xml = make_xml_message({:service => 'closeApplication'},'Kill',{'uid' => @_application_uid})
 
 		  # list application -- raises exception??
 		elsif @_command == :List
@@ -69,32 +71,32 @@ module MobyController
 		  # list applications		      
 		elsif @_command == :ListApps
 		  service_details = {:service => 'listApps', :name => @_application_name, :id => @_application_uid}
-		  command_xml = make_message(service_details, 'listApps', nil )
+		  command_xml = make_xml_message(service_details, 'listApps', nil )
 
 		  # list crashed applications
 		elsif @_command == :ListCrashedApps
 		  service_details = {:service => 'listCrashedApps', :name => @_application_name, :id => @_application_uid}
-		  command_xml = make_message(service_details, 'listCrashedApps', nil )
+		  command_xml = make_xml_message(service_details, 'listCrashedApps', nil )
 
 		  # shell command
 		elsif @_command == :Shell
-		  command_xml = make_message({:service => 'shellCommand'}, 'shellCommand', @_flags, @_application_name)
+		  command_xml = make_xml_message({:service => 'shellCommand'}, 'shellCommand', @_flags, @_application_name)
 
 		  # kill all application started by agent_qt
 		elsif @_command == :KillAll
-		  command_xml = make_message({:service =>'kill'},'Kill', nil)
+		  command_xml = make_xml_message({:service =>'kill'},'Kill', nil)
 
 		  # tap screen
 		elsif @_command == :TapScreen
-		  command_xml = make_message({:service =>'tapScreen'}, 'TapScreen', params)
+		  command_xml = make_xml_message({:service =>'tapScreen'}, 'TapScreen', params)
 
 		  # bring application to foreground
 		elsif @_command == :BringToForeground
-		  command_xml = make_message({:service => 'bringToForeground'},'BringToForeground', {'pid' => @_application_uid})
+		  command_xml = make_xml_message({:service => 'bringToForeground'},'BringToForeground', {'pid' => @_application_uid})
 		  
 		  # system info
 		elsif @_command == :SystemInfo
-		  command_xml = make_message({:service => 'systemInfo'}, 'systemInfo', nil)
+		  command_xml = make_xml_message({:service => 'systemInfo'}, 'systemInfo', nil)
 		  
 		  # start process memory logging
 		elsif @_command == :ProcessMemLoggingStart
@@ -105,7 +107,7 @@ module MobyController
 			'timestamp' => @_flags[ :timestamp ],
 			'interval_s' => @_flags[ :interval_s] }
 
-		  command_xml = make_message({:service => 'resourceLogging'}, 'ProcessMemLoggingStart', parameters)
+		  command_xml = make_xml_message({:service => 'resourceLogging'}, 'ProcessMemLoggingStart', parameters)
 
 
 		  # stop process memory logging
@@ -113,16 +115,16 @@ module MobyController
 		  parameters = {'thread_name' => @_application_name,
 			'return_data' => @_flags[ :return_data ]}
 
-		  command_xml = make_message({ :service =>'resourceLogging'}, 'ProcessMemLoggingStop',paremeters)
+		  command_xml = make_xml_message({ :service =>'resourceLogging'}, 'ProcessMemLoggingStop',paremeters)
 
 		  # start CPU load generating
 		elsif @_command == :CpuLoadStart
 		  parameters =  {'cpu_load' => @_flags[ :cpu_load ]}
-		  command_xml = make_message({:service => 'resourceLogging'},'CpuLoadStart',paremeters)
+		  command_xml = make_xml_message({:service => 'resourceLogging'},'CpuLoadStart',paremeters)
 
 		  # stop CPU load generating
 		elsif @_command == :CpuLoadStop
-		  command_xml = make_message({:service => 'resourceLogging'},'CpuLoadStop', nil)
+		  command_xml = make_xml_message({:service => 'resourceLogging'},'CpuLoadStop', nil)
 
 		  # unknown command
 		else
@@ -133,131 +135,7 @@ module MobyController
 		@sut_adapter.send_service_request( message, return_response_crc ) if message		
 	  end
 
-	  private 
-
-	  def make_parametrized_message( service_details, command_name, params, command_params = {} )
-
-		Nokogiri::XML::Builder.new{
-		  TasCommands( service_details ) {
-			Target( :TasId => "Application" ) {
-			  Command( ( params || {} ).merge( :name => command_name ) ){
-				command_params.collect{ | name, value | 
-				  param( :name => name, :value => value ) 
-				}					        
-			  }
-			}
-		  }
-		}.to_xml
-
-	  end
-
-	  def make_message( service_details, command_name, params, command_value = nil )
-
-		Nokogiri::XML::Builder.new{
-		  TasCommands( service_details ) {
-			Target( :TasId => "Application" ) {
-			  Command( command_value || "", ( params || {} ).merge( :name => command_name ) )
-			}
-		  }
-		}.to_xml		  
-
-	  end
-
-
-	  def encode_string( source )
-		source = source.to_s
-		source.gsub!( '&', '&' );
-		source.gsub!( '>', '>' );
-		source.gsub!( '<', '&lt;' );
-		source.gsub!( '"', '&quot;' );
-		source.gsub!( '\'', '&apos;' );
-		source
-	  end
-
-	  def make_filters
-
-		params = {}
-
-		# get sut paramteres only once, store to local variable
-		sut_parameters = MobyUtil::Parameter[ @_sut.id ]
-
-		params[ 'filterProperties' ] = $last_parameter if sut_parameters[ :filter_properties, nil ]
-		params[ 'pluginBlackList'  ] = $last_parameter if sut_parameters[ :plugin_blacklist,  nil ]
-		params[ 'pluginWhiteList'  ] = $last_parameter if sut_parameters[ :plugin_whitelist,  nil ]
-
-		case sut_parameters[ :filter_type, 'none' ]
-		  
-		when 'dynamic'
-
-		  # updates the filter with the current backtrace file list
-		  MobyUtil::DynamicAttributeFilter.instance.update_filter( caller( 0 ) ) 
-
-		  white_list = MobyUtil::DynamicAttributeFilter.instance.filter_string
-		  params['attributeWhiteList'] = white_list if white_list
-		  
-		when 'static'
-
-		  params['attributeBlackList'] = $last_parameter if sut_parameters[ :attribute_blacklist, nil ]
-		  params['attributeWhiteList'] = $last_parameter if sut_parameters[ :attribute_whitelist, nil ]
-		  
-		end
-
-		params		
-
-	  end
-	  
-	  def state_message
-		app_details = { :service => 'uiState', :name => @_application_name, :id => @_application_uid }
-		app_details[ :applicationUid ] = @_refresh_args[ :applicationUid ] if @_refresh_args.include?( :applicationUid )
-		
-		case MobyUtil::Parameter[ @_sut.id ][ :filter_type, 'none' ]
-		when 'none' 
-		  command_xml = make_message( app_details, 'UiState', @_flags || {} )
-		when 'dynamic'
-		  params = @_flags || {}
-		  params[ :filtered ] = 'true'
-		  command_xml = make_parametrized_message( app_details, 'UiState', params, make_filters )
-		else
-		  command_xml = make_parametrized_message( app_details, 'UiState', @_flags || {}, make_filters )
-		end
-		command_xml		
-	  end
-
-	  def run_message
-		#clone to not make changes permanent
-		arguments = MobyUtil::Parameter[ @_sut.id ][ :application_start_arguments, "" ].clone 
-		if @_arguments
-		  arguments << "," unless arguments.empty?
-		  arguments << @_arguments
-		end
-
-		parameters = { 
-		  'application_path' => @_application_name, 
-		  'arguments' => arguments, 
-		  'environment' => @_environment, 
-		  'events_to_listen' => @_events_to_listen, 
-		  'signals_to_listen' => @_signals_to_listen, 
-		  'start_command' => @_start_command 
-		}
-
-		make_message({:service => 'startApplication'}, 'Run', parameters)				
-	  end
-
-	  def close_message
-		sut_id = @_sut.id
-
-		parameters = {
-		  'uid' => @_application_uid, 
-		  'kill' => ( @_flags || {} )[ :force_kill ] || MobyUtil::Parameter[ sut_id ][ :application_close_kill ], 
-		  'wait_time' => MobyUtil::Parameter[ sut_id ][ :application_close_wait ] 		  
-		}
-
-		make_message({:service => 'closeApplication', :id => @_application_uid }, 'Close', parameters)
-	  end
-	  
-	  # enable hooking for performance measurement & debug logging
-	  MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
-	end #application
+	end # application
 
   end  # QT  	
 

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

@@ -22,6 +22,7 @@ module MobyController
   module QT
 
 	module FindObjectCommand
+	  include MobyUtil::FindObjectGenerator
 
 	  # Execute the command
 	  # Sends the message to the device using the @sut_adapter (see base class)     
@@ -30,79 +31,14 @@ module MobyController
 	  # == raises
 	  # NotImplementedError: raised if unsupported command type       
 	  def execute
-		filters = make_params if MobyUtil::Parameter[ @_sut.id ][ :filter_type, 'none' ] == 'dynamic'
-
-		params = search_parameters
-
-		builder = Nokogiri::XML::Builder.new do |xml|
-		  xml.TasCommands( ( application_details || {} ).merge( :service => "findObject") ) {			
-			xml.Target{			  
-			  add_objects(xml, params)
-			  xml.Command( :name => 'findObject' ){
-				filters.collect{ | name, value | 
-				  xml.param( :name => name, :value => value ) 
-				}					        
-			  } if MobyUtil::Parameter[ @_sut.id ][ :filter_type, 'none' ] == 'dynamic'
-			} if params and params.size > 0
-		  }
-		end
-		msg = builder.to_xml
-		#puts msg.to_s	
-
-		@sut_adapter.send_service_request(Comms::MessageGenerator.generate(msg), true)
-		
+		msg = generate_message
+		@sut_adapter.send_service_request(MobyController::QT::Comms::MessageGenerator.generate(msg), true)		
 	  end
 
 	  def set_adapter( adapter )
 		@sut_adapter = adapter
 	  end
 
-	  private
-
-	  def add_objects(builder, params)
-		parent = builder.parent
-		params.each{|objectParams| parent = create_object_node(builder, objectParams, parent)}			  
-	  end
-	  
-	  def create_object_node(builder, params, parent)
-		node = Nokogiri::XML::Node.new('object', builder.doc)
-		params.keys.each{|key| node[key.to_s] = params[key].to_s}
-		parent.add_child(node)
-	  end
-
-
-	  def make_params
-		params = {}
-
-        # get sut paramteres only once, store to local variable
-        sut_parameters = MobyUtil::Parameter[ @_sut.id ]
-
-		params[ 'filterProperties' ] = $last_parameter if sut_parameters[ :filter_properties, nil ]
-		params[ 'pluginBlackList'  ] = $last_parameter if sut_parameters[ :plugin_blacklist,  nil ]
-		params[ 'pluginWhiteList'  ] = $last_parameter if sut_parameters[ :plugin_whitelist,  nil ]
-
-        case sut_parameters[ :filter_type, 'none' ]
-		  
-		when 'dynamic'
-
-		  # updates the filter with the current backtrace file list
-		  MobyUtil::DynamicAttributeFilter.instance.update_filter( caller( 0 ) ) 
-
-		  white_list = MobyUtil::DynamicAttributeFilter.instance.filter_string
-		  params['attributeWhiteList'] = white_list if white_list
-          
-		when 'static'
-
-		  params['attributeBlackList'] = $last_parameter if sut_parameters[ :attribute_blacklist, nil ]
-		  params['attributeWhiteList'] = $last_parameter if sut_parameters[ :attribute_whitelist, nil ]
-          
-        end
-
-		params		
-
-	  end
-
-
 	  # enable hooking for performance measurement & debug logging
 	  MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
 

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

@@ -22,6 +22,7 @@ module MobyController
 	module QT
 
 		module Fixture 
+		  include MobyUtil::MessageComposer
 
 			# Execute the command
 			# Sends the message to the device using the @sut_adapter (see base class)     
@@ -30,25 +31,10 @@ module MobyController
 			# == raises
 			# NotImplementedError: raised if unsupported command type       
 			def execute
-				
-				Kernel::raise ArgumentError.new( "Fixture '%s' not found for sut id '%s'" % [ @name, @sut_adapter.sut_id ] ) if ( fixture_plugin =  MobyUtil::Parameter[ @sut_adapter.sut_id.to_sym ][ :fixtures ][ @name.to_sym, nil ] ).nil?
+				Kernel::raise ArgumentError.new( "Fixture '%s' not found for sut id '%s'" % [ @name, @sut_adapter.sut_id ] ) if ( plugin_params =  MobyUtil::Parameter[ @sut_adapter.sut_id.to_sym ][ :fixtures ][ @params[:name].to_sym, nil ] ).nil?
 
-
-				@sut_adapter.send_service_request(
-					Comms::MessageGenerator.generate(
- 						Nokogiri::XML::Builder.new{
-							TasCommands( :id => @context.application_id, :transitions => @context.transitions, :service => "fixture", :async => @context.asynchronous ) {
-								Target( :TasId => @context.object_id, :type => @context.object_type ) {
-									Command( :name => "Fixture", :plugin => fixture_plugin, :method => @context.command ) {
-										@context.params.collect{ | name, value | 
-											param( :name => name, :value => value )
-										}
-									}
-								}
-							}
-						}.to_xml
-					)
-				)
+     		    fixture_plugin = plugin_params[:plugin]
+				@sut_adapter.send_service_request(Comms::MessageGenerator.generate(make_fixture_message(fixture_plugin, @params)))
 
 			end
 

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

@@ -18,7 +18,7 @@
 ############################################################################
 
 # verify that TDriver is loaded
-Kernel::raise RuntimeError.new( "SUT plugin requires TDriver" ) unless (defined?( MATTI ) || defined?( TDriver ))
+Kernel::raise RuntimeError.new( "This SUT plugin requires Testability Driver and cannot be launched in standalone mode" ) unless (defined?( MATTI ) || defined?( TDriver ))
 
 module MobyPlugin
 

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

@@ -20,205 +20,222 @@
 module MobyController
 
   module QT
-	
-	# Sut adapter that used TCP/IP connections to send and receive data from QT side. 
-	class SutAdapter < MobyController::SutAdapter
-	  
-	  attr_reader :sut_id
-
-	  attr_accessor(
-
-					:socket_read_timeout,
-					:socket_write_timeout,
-					:socket_received_bytes,
-					:socket_sent_bytes
-
-					)
-	  
-	  # TODO: better way to set the host and port parameters   
-	  # Initialize the tcp adapter for communicating with the device.
-	  # Communication is done using two tcp channels one form commanding
-	  # the device and one for receiving ui state data.
-	  # UI state data receivin is done in a seprate thread so it is good
-	  # once usage is complete the shutdown_comms is called
-	  # == params
-	  # 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 )
-
-		@socket = nil
-		@connected = false
+    
+    # Sut adapter that used TCP/IP connections to send and receive data from QT side. 
+    class SutAdapter < MobyController::SutAdapter
+      
+      attr_reader :sut_id
+
+      attr_accessor(
+
+            :socket_read_timeout,
+            :socket_write_timeout,
+            :socket_received_bytes,
+            :socket_sent_bytes
+
+            )
+      
+      # TODO: better way to set the host and port parameters   
+      # Initialize the tcp adapter for communicating with the device.
+      # Communication is done using two tcp channels one form commanding
+      # the device and one for receiving ui state data.
+      # UI state data receivin is done in a seprate thread so it is good
+      # once usage is complete the shutdown_comms is called
+      # == params
+      # 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 )
+
+        @socket = nil
+        @connected = false
         @socket_received_bytes=0
         @socket_sent_bytes=0
 
-		@sut_id = sut_id
+        @sut_id = sut_id
 
-		# set timeouts
-		@socket_read_timeout = receive_timeout
-		@socket_write_timeout = send_timeout
+        # set timeouts
+        @socket_read_timeout = receive_timeout
+        @socket_write_timeout = send_timeout
 
-		@counter = rand( 1000 )
+        @counter = rand( 1000 )
 
-		# connect socket
-		#connect( @sut_id )
+        # connect socket
+        #connect( @sut_id )
 
-	  end
+      end
 
-	  def disconnect
+      def disconnect
 
-		@socket.close if @connected
+        @socket.close if @connected
 
-		@connected = false
+        @connected = false
 
-	  end
+      end
 
-	  def connect( id = nil )
+      def connect( id = nil )
 
-		id ||= @sut_id
+        id ||= @sut_id
 
-		begin
+        begin
 
-		  @socket = TCPSocket.open( MobyUtil::Parameter[ id ][ :qttas_server_ip ], MobyUtil::Parameter[ id ][ :qttas_server_port ].to_i )
+          @socket = TCPSocket.open( MobyUtil::Parameter[ id ][ :qttas_server_ip ], MobyUtil::Parameter[ id ][ :qttas_server_port ].to_i )
 
-		rescue => ex
+        rescue => ex
 
-		  ip = "no ip" if ( ip = MobyUtil::Parameter[ id ][ :qttas_server_ip, "" ] ).empty?
-		  port = "no port" if ( port = MobyUtil::Parameter[ id ][ :qttas_server_port, "" ] ).empty?
+          ip = "no ip" if ( ip = MobyUtil::Parameter[ id ][ :qttas_server_ip, "" ] ).empty?
+          port = "no port" if ( port = MobyUtil::Parameter[ id ][ :qttas_server_port, "" ] ).empty?
 
-		  Kernel::raise IOError.new("Unable to connect QTTAS server, verify that it is running properly (#{ ip }:#{ port }): .\nException: #{ ex.message }")
-		end
+          Kernel::raise IOError.new("Unable to connect QTTAS server, verify that it is running properly (#{ ip }:#{ port }): .\nException: #{ ex.message }")
+        end
 
-		@connected = true
-
-	  end
-
-	  def group?
-		@_group
-	  end
-
-	  # Set the document builder for the grouped behaviour message.
-	  def set_message_builder(builder)
-		@_group = true
-		@_builder = builder
-	  end
-
-	  def append_command(node_list)		  
-		node_list.each {|ch| @_builder.doc.root.add_child(ch)}				  
-	  end
-
-	  # Sends a grouped command message to the server. Sets group to false and nils the builder
-	  # to prevent future behviours of being grouped (unless so wanted)
-	  # == returns    
-	  # the amout of commands grouped (and send)
-	  def send_grouped_request
-		@_group = false
-		size = @_builder.doc.root.children.size
-		send_service_request(Comms::MessageGenerator.generate(@_builder.to_xml))
-		@_builder = nil
-		size
-	  end
-
-	  # Send the message to the qt server         
-	  # If there is no exception propagated the send to the device was successful
-	  # == params   
-	  # message:: message in qttas protocol format   
-	  # == returns    
-	  # the response body
-	  def send_service_request( message, return_crc = false )
-
-		connect if !@connected        
-
-		# set request message id
-		message.message_id = ( @counter += 1 )
-
-		# write request message to socket
-		write_socket( message.make_binary_message(@counter) )
-
-		# read response to determine was the message handled properly and parse the header
-		# header[ 0 ] = command_flag
+        @connected = true
+
+      end
+
+      def group?
+        @_group
+      end
+
+      # Set the document builder for the grouped behaviour message.
+      def set_message_builder(builder)
+        @_group = true
+        @_builder = builder
+      end
+
+      def append_command(node_list)
+        node_list.each {|ch| @_builder.doc.root.add_child(ch)}          
+      end
+
+      # Sends a grouped command message to the server. Sets group to false and nils the builder
+      # to prevent future behviours of being grouped (unless so wanted)
+      # == returns    
+      # the amout of commands grouped (and send)
+      def send_grouped_request
+        @_group = false
+        size = @_builder.doc.root.children.size
+        send_service_request(Comms::MessageGenerator.generate(@_builder.to_xml))
+        @_builder = nil
+        size
+      end
+
+      # Send the message to the qt server         
+      # If there is no exception propagated the send to the device was successful
+      # == params   
+      # message:: message in qttas protocol format   
+      # == returns    
+      # the response body
+      def send_service_request( message, return_crc = false )
+
+        connect if !@connected        
+
+        # set request message id
+        message.message_id = ( @counter += 1 )
+
+        # write request message to socket
+        write_socket( message.make_binary_message(@counter) )
+
+        # 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
-		header = nil
-		body = nil
-
-		read_message_id = 0
-		until read_message_id == @counter
-		  header = read_socket( 12 ).unpack( 'CISCI' )
-
-		  # read the message body and compare crc checksum
-		  Kernel::raise IOError.new( "CRC do not match. Maybe the message is corrupted!" ) if CRC::Crc16.crc16_ibm( body = read_socket( header[ 1 ] ) , 0xffff ) != 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
-		  read_message_id = header[ 4 ]
-		  if read_message_id < @counter
-			MobyUtil::Logger.instance.log "warning" , "Response to request did not match: \"#{ header[ 4 ].to_s }\"<\"#{ @counter.to_s }\""
-		  elsif read_message_id > @counter
-			MobyUtil::Logger.instance.log "fatal" , "Response to request did not match: \"#{ header[ 4 ].to_s }\">\"#{ @counter.to_s }\""
-			# save to file?
-			MobyUtil::Logger.instance.log "fatal" , body
-			Kernel::raise RuntimeError.new( "Response to request did not match: \"#{ header[ 4 ].to_s }\"!=\"#{ @counter.to_s }\"" )
-		  end
-		end
-		
+
+        header = nil
+        body = nil
+
+        read_message_id = 0
+
+        until read_message_id == @counter
+        
+          header = read_socket( 12 ).unpack( 'CISCI' )
+
+          # read the message body and compare crc checksum
+          Kernel::raise IOError.new( "CRC do not match. Maybe the message is corrupted!" ) if CRC::Crc16.crc16_ibm( body = read_socket( header[ 1 ] ) , 0xffff ) != 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
+          read_message_id = header[ 4 ]
+
+          if read_message_id < @counter
+
+            MobyUtil::Logger.instance.log "warning" , "Response to request did not match: \"#{ header[ 4 ].to_s }\"<\"#{ @counter.to_s }\""
+
+          elsif read_message_id > @counter
+
+            MobyUtil::Logger.instance.log "fatal" , "Response to request did not match: \"#{ header[ 4 ].to_s }\">\"#{ @counter.to_s }\""
+
+            # save to file?
+            MobyUtil::Logger.instance.log "fatal" , body
+            Kernel::raise RuntimeError.new( "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 )
-		  
+      
           body = Zlib::Inflate.inflate( body ) unless ( body = body[ 4..-1 ] ).empty?
 
         end
 
         # raise exception if messages error flag is set
-		# Flag statuses:
-		#   0 -> ERROR_MSG
+        # Flag statuses:
+        #   0 -> ERROR_MSG
         #   1 -> VALID_MSG
         #   2 -> OK_MESSAGE
-		Kernel::raise RuntimeError.new( body ) if header[ 0 ] == 0
+		if header[ 0 ] == 0
+		  if body =~ /The application with Id \d+ is no longer available/
+			Kernel::raise MobyBase::ApplicationNotAvailableError.new( body ) 
+		  else
+			Kernel::raise RuntimeError.new( body ) 
+		  end
+		end
 
-		# return the body ( and crc if required )
-		return_crc ? [ body, header[ 2 ] ] : body
+        # return the body ( and crc if required )
+        return_crc ? [ body, header[ 2 ] ] : body
 
-	  end
+      end
 
-	  private
+    private
 
-	  def read_socket( bytes_count )
+      def read_socket( bytes_count )
 
-		# store time before start receving data
-		start_time = Time.now
+        # store time before start receving data
+        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?
+        # 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?
 
-		# read data from socket
-		read_buffer = @socket.read( bytes_count ){
+        # 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
+          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
 
-		}
+        }
 
-		Kernel::raise IOError.new( "Socket reading error for %i bytes - No data retrieved" % [ bytes_count ] ) if read_buffer.nil?
-        @socket_received_bytes+=read_buffer.size
-		read_buffer
+        Kernel::raise IOError.new( "Socket reading error for %i bytes - No data retrieved" % [ bytes_count ] ) if read_buffer.nil?
 
-	  end
+        @socket_received_bytes += read_buffer.size
+        read_buffer
 
-	  def write_socket( data )
-        @socket_sent_bytes+=data.size
+      end
 
-		@socket.write( data )
+      def write_socket( data )
+      
+        @socket_sent_bytes += data.size
 
-		# 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?
+        @socket.write( data )
 
-	  end
+        # 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?
 
-	  # enable hooking for performance measurement & debug logging
-	  MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+      end
 
+      # enable hooking for performance measurement & debug logging
+      MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
 
-	end # SutAdapter
+    end # SutAdapter
 
   end # QT