testability-driver-qt-sut-plugin 1.3.2 → 1.4.0

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

@@ -710,6 +710,39 @@ module MobyBehaviour
         end
       end
 
+      # == description
+      # Does MemSpy heap dump from the given application. The dump will be
+      # saved in a file, which need to be separately fetched from the device.\ŋ
+      # \n
+      # [b]NOTE:[/b] Only supported on Symbian platform.
+      #
+      # == arguments
+      # thread_name
+      #  String
+      #   description: Name of the application thread.
+      #   example: 'phonebook2'
+      #
+      # == returns
+      # String
+      #   description: Response message
+      #   example: 'OK'
+      #
+      def dump_heap(thread_name)
+        status = nil
+        begin
+          status = execute_command(MobyCommand::Application.new(
+                                      :ThreadHeapDump,
+                                      {:application_name => thread_name}
+                                    )
+                                  )
+          $logger.behaviour "PASS;Successfully dumped thread heap.;#{ id };sut;{};dump_heap;"
+        rescue Exception => e
+          $logger.behaviour "FAIL;Failed to dump thread heap.;#{ id };sut;{};dump_heap;"
+          raise RuntimeError, "Unable to dump thread heap: Exception: #{ e.message } (#{ e.class })"
+        end
+        status
+      end
+
       # == description
       # Groups behaviours into a single message. Commands are executed in the target in sequence using the given interval as timeout between the commands. The interval is not quaranteed to be exactly the specified amount and will vary depending on the load in the target device. Therefore it is not recommended to use the interval as basis for the test results. The commands are all executed in the target device in a single roundtrip from TDriver to the target device so no verification will or can be done between the commands so do not group behaviours which change the ui in a way that the next command may fail. Best use cases for the grouping is static behaviours such as virtual keyboard button taps. Behaviours can only be qrouped for one application at a time and you need to provide the application object as parameter. Sut behaviours cannot be grouped.
       # == arguments

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

@@ -159,7 +159,7 @@ module MobyController
           #when :List
 
             #raise ArgumentError, "Unknown command! #{ @_command.to_s }"
-        
+            
         else
         
           # unknown command

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

@@ -115,7 +115,11 @@ module MobyPlugin
           $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
+          $parameters[ sut_id ][ :socket_write_timeout, "25" ].to_i,
+
+          # tcp/ip connection timeouts, default: 15 (seconds)
+          $parameters[ sut_id ][ :socket_connect_timeout, "15" ].to_i
+
 
         )
 

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

@@ -35,6 +35,7 @@ module MobyController
       attr_accessor(
         :socket_read_timeout,
         :socket_write_timeout,
+        :socket_connect_timeout,
         :deflate_service_request,
         :deflate_minimum_size,
         :deflate_compression_level
@@ -48,7 +49,7 @@ module MobyController
       # 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 )
+      def initialize( sut_id, receive_timeout = 25, send_timeout = 25, connect_timeout = 25 )
 
         # reset socket
         @socket = nil
@@ -72,6 +73,7 @@ module MobyController
         # set timeouts
         @socket_read_timeout = receive_timeout
         @socket_write_timeout = send_timeout
+        @socket_connect_timeout = connect_timeout
 
         # randomized value for initial message packet counter
         @counter = rand( 1000 )
@@ -116,6 +118,32 @@ module MobyController
 
       end
 
+      def timeout_capable_socket_opener(ip,port,timeout=nil)
+        addr = Socket.getaddrinfo(ip, nil)
+        sock = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
+        if timeout
+           secs = Integer(timeout)
+           usecs = Integer((timeout - secs) * 1_000_000)
+           optval = [secs, usecs].pack("l_2")
+           ## actual timeout gets triggered after 2 times of "timeout" value, most likely because my patch applies timeout to read AND write ..
+           sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+           sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+           ## also, worth checking if there's actually some Socket::SO_*  that applies the timeout to connection forming ..
+        end
+        begin
+           sock.connect_nonblock(Socket.pack_sockaddr_in(port, addr[0][3]))
+        rescue Errno::EINPROGRESS
+           resp = IO.select([sock],nil, nil, timeout.to_i)
+           begin
+              sock.connect_nonblock(Socket.pack_sockaddr_in(port, addr[0][3]))
+           rescue Errno::EISCONN
+           end
+        end
+        sock ## Its also worth noting that if we set RCV AND SNDTIMEOT to some value when checking for established socket,
+             ## it might make sense to set the defaults values back again so that only during the connection, timeout is
+             ## different..
+      end
+
       # TODO: document me
       def connect( id = nil )
 
@@ -135,8 +163,15 @@ module MobyController
           execute_hook( 'before_connect', id, ip, port ) if hooked?( 'before_connect' ) 
 
           # open tcp/ip connection
+          # Using ruby TCPSocket this way will utilize the underlying kernel to do the timeout, which by default is too long (In my tests, on ubuntu 10.10, TCPSocket.open
+          # will wait for exactly 380 seconds before throwing exception which is *FAR* too long ..
           @socket = TCPSocket.open( ip, port )
 
+
+          # open tcp/ip connectio
+          ## The block will actually double the time, so halve it. Actual timeout will +1 if it's an odd number
+#          @socket = timeout_capable_socket_opener(ip,port,(@socket_connect_timeout.to_i / 2.0).ceil)
+
           # set connected status to true
           @connected = true
 

data/xml/behaviour/qt.xml

@@ -73,6 +73,10 @@
                 <description>Stop generating CPU load.</description>
                 <example>cpu_load_stop</example>
             </method>
+            <method name="dump_heap">
+                <description>Capture thread heap dump.</description>
+                <example>dump_heap('akncapserver')</example>
+            </method>
             <method name="group_behaviours">
                 <description>Group behaviours into a single message.</description>
                 <example>group_behaviours(1, app){app.Node.tap;app.Node1.tap}</example>

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: testability-driver-qt-sut-plugin
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 7
   prerelease: false
   segments: 
   - 1
-  - 3
-  - 2
-  version: 1.3.2
+  - 4
+  - 0
+  version: 1.4.0
 platform: ruby
 authors: 
 - TDriver team
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-26 00:00:00 +03:00
+date: 2011-11-11 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency