testability-driver 1.2.1 → 1.3.0

data/lib/tdriver/util/video/camera_linux.rb

@@ -17,6 +17,8 @@
 ## 
 ############################################################################
 
+require 'open3'
+
 module MobyUtil
   
   # Linux streamer webcam implementation
@@ -25,7 +27,7 @@ module MobyUtil
 
     STARTUP_TIMEOUT = 60
 
-    DEFAULT_OPTIONS = { :device => '/dev/video0', :width => 320, :height => 240, :fps => 5 }
+    DEFAULT_OPTIONS = { :device => '/dev/video0', :width => 320, :height => 240, :fps => 5, :max_time => '99:00:00' }
 
     # TODO: document me
     def self.new_cam( *args )
@@ -51,6 +53,7 @@ module MobyUtil
       @_video_file = video_file
       @_rec_options = DEFAULT_OPTIONS.merge user_options
           
+      @rec_app = 'streamer'
     end
     
     # Starts recording based on options given during initialization
@@ -67,15 +70,13 @@ module MobyUtil
           # no reaction to failed file ops, unless recording fails
         end
       end  
-
-      rec_command = 'streamer -q -c ' + @_rec_options[ :device ].to_s + ' -f rgb24 -r ' + @_rec_options[ :fps ].to_s + ' -t 99:00:00 -o ' +  @_video_file.to_s + ' -s ' + @_rec_options[ :width ].to_s + 'x' + @_rec_options[ :height ].to_s
-
-      @_streamer_pid = fork do
-        begin
-          Kernel::exec( rec_command )
-        rescue Exception => e
-          raise RuntimeError.new( "An error was encountered while launching streamer:\n" << e.inspect )
-        end
+      
+      rec_opts = ' -q -c ' + @_rec_options[ :device ].to_s + ' -f rgb24 -r ' + @_rec_options[ :fps ].to_s + ' -t ' + 
+        @_rec_options[:max_time] + ' -o ' +  @_video_file.to_s + ' -s ' + @_rec_options[ :width ].to_s + 'x' + @_rec_options[ :height ].to_s 
+      begin         
+        @stdin, @stdout, @stderr = Open3.popen3(@rec_app + rec_opts)
+      rescue => e
+        raise RuntimeError.new( "An error was encountered while launching streamer:\n" << e.inspect )
       end
 
       file_timed_out = false
@@ -94,11 +95,8 @@ module MobyUtil
       if file_timed_out
 
         # make sure recording is not initializing, clean up any failed file        
-        begin
-          Process.kill( 9, @_streamer_pid.to_i )
-        rescue
-        end
-        
+        stop_recording
+
         if File.exists?( @_video_file )
           begin
             File.delete( @_video_file )
@@ -113,8 +111,9 @@ module MobyUtil
       @_recording = true
       
       nil
-      
     end
+
+
         
     # Stops ongoing recording    
     def stop_recording 
@@ -122,14 +121,29 @@ module MobyUtil
       if @_recording      
 
         @_recording = false            
-
-        Process.kill( 9, @_streamer_pid.to_i )
-
+        
+        begin
+          @stdin.close unless @stdin.closed?
+          @stdout.close unless @stdout.closed?
+          @stderr.close unless @stderr.closed?
+          
+          sleep 10 # allow some time to close (yes, it can take up to 10 seconds)
+          pid = `pidof #{@rec_app}`.to_i
+          begin 
+            if pid != 0
+              Process.kill(9,pid)
+            end
+          rescue => e
+            puts "Got error " + e.inspect
+          end
+        rescue => e
+          raise RuntimeError.new( "Failed to end recording. Errror:\n " << e.inspect)
+        end
       end
-
+      
       nil
-
-    end    
+      
+    end
     
     # enable hooking for performance measurement & debug logging
     TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )

data/lib/tdriver/util/xml/parsers/nokogiri/abstraction.rb

@@ -44,10 +44,6 @@ module MobyUtil
         # TODO: document me
         def cache( key, value )
 
-          yield
-
-# JKo: disable xml caching for now, need more investigation why tests starts to fail
-=begin
           if @options[ :cache_enabled ] == true
           
             @cache[ key ].fetch( value ){
@@ -61,7 +57,6 @@ module MobyUtil
             yield
               
           end
-=end
                 
         end
       
@@ -78,13 +73,6 @@ module MobyUtil
 
         include Cache
 
-        # TODO: Documentation
-        def empty?
-
-          cache( :is_nil, :value ){ @xml.nil? }
-
-        end
-
         # TODO: Documentation
         def name
 
@@ -95,10 +83,12 @@ module MobyUtil
         # TODO: Documentation
         def nil?
 
-          cache( :is_nil, :value ){ @xml.nil? }
+          cache( :nil?, :value ){ @xml.nil? }
 
         end
 
+        alias :empty? :nil?
+
         # TODO: Documentation
         def size
 

data/lib/tdriver/util/xml/parsers/nokogiri/node.rb

@@ -30,7 +30,7 @@ module MobyUtil
         # TODO: document me
         def []( value )
 
-          cache( __method__, value ){ @xml[ value ] }
+          cache( :[], value ){ @xml[ value ] }
 
         end
 
@@ -46,7 +46,7 @@ module MobyUtil
         # TODO: document me
         def ==( object )
 
-          cache( __method__, object.object_id ){ @xml.content == object.xml.content }
+          cache( :==, object.object_id ){ @xml.content == object.xml.content }
           
         end
 
@@ -56,7 +56,7 @@ module MobyUtil
         # TODO: document me
         def <=>( object )
 
-          cache( __method__, object.object_id ){ @xml <=> object.xml }
+          cache( :<=>, object.object_id ){ @xml <=> object.xml }
 
         end
 
@@ -80,10 +80,15 @@ module MobyUtil
         def attributes
 
           cache( :attributes, :value ){
-            # return hash of attributes
-            Hash[ @xml.attribute_nodes.collect{ | node | 
-              [ node.node_name, node.value.to_s ] }
-            ]
+            
+            # return hash of attributes            
+            #Hash[ @xml.attribute_nodes.collect{ | node | 
+            #  [ node.node_name, node.value.to_s ] }
+            #]
+
+            # approx. 20% faster
+            @xml.attribute_nodes.inject({}){ | result, node | result[ node.node_name ] = node.value; result }
+
           }
 
         end
@@ -91,7 +96,7 @@ module MobyUtil
         # TODO: document me
         def blank?
 
-          cache( :is_blank, :value ){ @xml.blank? }
+          cache( :blank?, :value ){ @xml.blank? }
 
         end
 

data/lib/tdriver/util/xml/parsers/nokogiri/nodeset.rb

@@ -35,7 +35,7 @@ module MobyUtil
 
         def first
 
-          cache( :first, :vaue ){ node_object( @xml.first ) }
+          cache( :first, :value ){ node_object( @xml.first ) }
 
         end
 
@@ -47,13 +47,26 @@ module MobyUtil
 
         def each( &block )
 
-          @xml.each{ | node | 
+          #@xml.each{ | node | 
+          #  yield( cache( :each, node ){ node_object( node ) } ) 
+          #}
 
-            yield( cache( :each, node ){ node_object( node ) } ) 
+          # approx. 3,5% faster
+          cache( :each, :cached_nodes ){ 
 
-          }
+            @xml.collect{ | node | 
 
-          self
+              cache( :each, node ){ node_object( node ) }
+
+            }
+
+          }.each{ | node | 
+
+            yield( node ) 
+
+          } 
+
+         self
 
         end
 
@@ -87,7 +100,7 @@ module MobyUtil
 
         def compact
 
-          cache( :compact, :value ){ nodeset_object( @xml.compact ) }
+          cache( :compact, :value ){ node_object( @xml.compact ) }
 
         end
 
@@ -99,9 +112,23 @@ module MobyUtil
 
         end
 
+        def inject( result, &block )
+
+          cache( :each, :cached_nodes ){ 
+
+            @xml.collect{ | node | 
+
+              cache( :each, node ){ node_object( node ) }
+
+            }
+
+          }.__send__( :inject, result, &block )
+
+        end
+
         def sort( &block )
 
-          nodeset_object( _sort( &block ) ) 
+          node_object( _sort( &block ) ) 
 
         end
 
@@ -117,7 +144,7 @@ module MobyUtil
 
         def empty?
 
-          cache( :is_empty, :value ){ @xml.empty? }
+          cache( :empty?, :value ){ @xml.empty? }
 
         end
         
@@ -161,7 +188,22 @@ module MobyUtil
 
         def _collect( &block )
 
-          @xml.collect{ | node | yield( cache( :each, node ){ node_object( node ) } ) }
+          #@xml.collect{ | node | yield( cache( :each, node ){ node_object( node ) } ) }
+
+          # approx. 3.5% faster
+          cache( :each, :cached_nodes ){ 
+
+            @xml.collect{ | node | 
+
+              cache( :each, node ){ node_object( node ) }
+
+            }
+
+          }.collect{ | node | 
+
+            yield( node )
+
+          }
 
         end
 

data/lib/tdriver/util/xml/xml.rb

@@ -141,6 +141,7 @@ module MobyUtil
 
       begin
 
+=begin
         unless crc.nil?
 
           [ Document.new( xml_string ), false ]
@@ -150,9 +151,10 @@ module MobyUtil
           Document.new( xml_string )
         
         end
+=end
 
 # JKo: disable xml caching for now, need more investigation why tests starts to fail
-=begin
+#=begin
         unless crc.nil?
 
           if @document_cache[ :cache ].include?( crc )
@@ -202,7 +204,7 @@ module MobyUtil
           Document.new( xml_string )
 
         end
-=end
+#=end
       rescue
 
         if $TDRIVER_INITIALIZED == true

data/lib/tdriver/verify/verify.rb

@@ -47,7 +47,7 @@ module TDriverVerify
 
       rescue Exception
 
-        raise exception.class, "Exception was raised while executing on_error_verify_block. Reason: #{ $!.message.to_s }"
+        raise $!.class, "Exception was raised while executing on_error_verify_block. Reason: #{ $!.message.to_s }"
 
       end
 
@@ -83,18 +83,21 @@ module TDriverVerify
       # disable behaviour logging
       $logger.enabled = false
 
-      # ensure that code block was given
-      raise ArgumentError, "No block was given." unless block_given?
-
       # ensure that timeout is either nil or type of integer
-      raise ArgumentError, "wrong argument type #{ timeout.class } for timeout (expected Fixnum or NilClass)" unless [ NilClass, Fixnum ].include?( timeout.class )
+      timeout.check_type [ Integer, NilClass ], 'wrong argument type $1 for timeout (expected $2)'
 
       # ensure that message is either nil or type of string
-      raise ArgumentError, "Argument message was not a String" unless [ NilClass, String ].include?( message.class ) 
+      message.check_type [ String, NilClass ], 'wrong argument type $1 for exception message (expected $2)'
+
+      # verify that block was given
+      raise LocalJumpError, 'unable to verify due to no code block was given' unless block_given?
 
       # convert timeout to integer, nil will be zero
       timeout = get_timeout( timeout )
 
+      # verify that timeout is valid
+      timeout.not_negative 'timeout value cannot be negative'
+
       # calculate the time when timeout exceeds
       timeout_end_time = Time.now + timeout
 
@@ -127,7 +130,7 @@ module TDriverVerify
           raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
 
           # refresh and retry unless timeout exceeded
-          raise $! if Time.new > timeout_end_time
+          raise $! if Time.now > timeout_end_time
           
           # retry interval
           sleep TIMEOUT_CYCLE_SECONDS
@@ -204,18 +207,21 @@ module TDriverVerify
       # disable behaviour logging
       $logger.enabled = false
 
-      # ensure that code block was given
-      raise ArgumentError, "No block was given." unless block_given?
-
       # ensure that timeout is either nil or type of integer
-      raise ArgumentError, "wrong argument type #{ timeout.class } for timeout (expected Fixnum or NilClass)" unless [ NilClass, Fixnum ].include?( timeout.class )
+      timeout.check_type [ Integer, NilClass ], 'wrong argument type $1 for timeout (expected $2)'
 
       # ensure that message is either nil or type of string
-      raise ArgumentError, "Argument message was not a String" unless [ NilClass, String ].include?( message.class ) 
+      message.check_type [ String, NilClass ], 'wrong argument type $1 for exception message (expected $2)'
+
+      # verify that block was given
+      raise LocalJumpError, 'unable to verify due to no code block was given' unless block_given?
 
       # convert timeout to integer, nil will be zero
       timeout = get_timeout( timeout )
 
+      # verify that timeout is valid
+      timeout.not_negative 'timeout value cannot be negative'
+
       # calculate the time when timeout exceeds
       timeout_end_time = Time.now + timeout
 
@@ -253,7 +259,7 @@ module TDriverVerify
         end
 
         # refresh and retry unless timeout exceeded
-        raise $! if Time.new > timeout_end_time
+        raise $! if Time.now > timeout_end_time
         
         # retry interval
         sleep TIMEOUT_CYCLE_SECONDS
@@ -337,18 +343,21 @@ module TDriverVerify
       # disable behaviour logging
       $logger.enabled = false
 
-      # ensure that code block was given
-      raise ArgumentError, "No block was given." unless block_given?
-
       # ensure that timeout is either nil or type of integer
-      raise ArgumentError, "wrong argument type #{ timeout.class } for timeout (expected Fixnum or NilClass)" unless [ NilClass, Fixnum ].include?( timeout.class )
+      timeout.check_type [ Integer, NilClass ], 'wrong argument type $1 for timeout (expected $2)'
 
       # ensure that message is either nil or type of string
-      raise ArgumentError, "Argument message was not a String" unless [ NilClass, String ].include?( message.class ) 
+      message.check_type [ String, NilClass ], 'wrong argument type $1 for exception message (expected $2)'
+
+      # verify that block was given
+      raise LocalJumpError, 'unable to verify due to no code block was given' unless block_given?
 
       # convert timeout to integer, nil will be zero
       timeout = get_timeout( timeout )
 
+      # verify that timeout is valid
+      timeout.not_negative 'timeout value cannot be negative'
+
       # calculate the time when timeout exceeds
       timeout_end_time = Time.now + timeout
 
@@ -387,7 +396,7 @@ module TDriverVerify
           raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
 
           # refresh and retry unless timeout exceeded
-          raise $! if Time.new > timeout_end_time
+          raise $! if Time.now > timeout_end_time
           
           # retry interval
           sleep TIMEOUT_CYCLE_SECONDS
@@ -473,18 +482,21 @@ module TDriverVerify
       # disable behaviour logging
       $logger.enabled = false
 
-      # ensure that code block was given
-      raise ArgumentError, "No block was given." unless block_given?
-
       # ensure that timeout is either nil or type of integer
-      raise ArgumentError, "wrong argument type #{ timeout.class } for timeout (expected Fixnum or NilClass)" unless [ NilClass, Fixnum ].include?( timeout.class )
+      timeout.check_type [ Integer, NilClass ], 'wrong argument type $1 for timeout (expected $2)'
 
       # ensure that message is either nil or type of string
-      raise ArgumentError, "Argument message was not a String" unless [ NilClass, String ].include?( message.class ) 
+      message.check_type [ String, NilClass ], 'wrong argument type $1 for exception message (expected $2)'
+
+      # verify that block was given
+      raise LocalJumpError, 'unable to verify due to no code block was given' unless block_given?
 
       # convert timeout to integer, nil will be zero
       timeout = get_timeout( timeout )
 
+      # verify that timeout is valid
+      timeout.not_negative 'timeout value cannot be negative'
+
       # calculate the time when timeout exceeds
       timeout_end_time = Time.now + timeout
 
@@ -523,7 +535,7 @@ module TDriverVerify
           raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
 
           # refresh and retry unless timeout exceeded
-          raise $! if Time.new > timeout_end_time
+          raise $! if Time.now > timeout_end_time
           
           # retry interval
           sleep TIMEOUT_CYCLE_SECONDS
@@ -581,7 +593,7 @@ module TDriverVerify
   
   end
 
-  # Verifies that the block given to this method evaluates to the expected value. Verification is synchronized with all connected suts.
+  # Verifies that result of given block equals to expected value. Verification is synchronized with all connected suts.
   # If this method is called for a sut, synchronization is only done with that sut.
   #
   # === params
@@ -607,18 +619,21 @@ module TDriverVerify
       # disable behaviour logging
       $logger.enabled = false
 
-      # ensure that code block was given
-      raise ArgumentError, "No block was given." unless block_given?
-
       # ensure that timeout is either nil or type of integer
-      raise ArgumentError, "wrong argument type #{ timeout.class } for timeout (expected Fixnum or NilClass)" unless [ NilClass, Fixnum ].include?( timeout.class )
+      timeout.check_type [ Integer, NilClass ], 'wrong argument type $1 for timeout (expected $2)'
 
       # ensure that message is either nil or type of string
-      raise ArgumentError, "Argument message was not a String" unless [ NilClass, String ].include?( message.class ) 
+      message.check_type [ String, NilClass ], 'wrong argument type $1 for exception message (expected $2)'
+
+      # verify that block was given
+      raise LocalJumpError, 'unable to verify due to no code block was given' unless block_given?
 
       # convert timeout to integer, nil will be zero
       timeout = get_timeout( timeout )
 
+      # verify that timeout is valid
+      timeout.not_negative 'timeout value cannot be negative'
+
       # calculate the time when timeout exceeds
       timeout_end_time = Time.now + timeout
 
@@ -657,7 +672,7 @@ module TDriverVerify
           raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
 
           # refresh and retry unless timeout exceeded
-          raise $! if Time.new > timeout_end_time
+          raise $! if Time.now > timeout_end_time
           
           # retry interval
           sleep TIMEOUT_CYCLE_SECONDS
@@ -715,21 +730,20 @@ module TDriverVerify
   
   end
 
-  # Verifies that the block given to return value matches with expected regular expression pattern. Verification is synchronized with all connected suts.
+  # Verifies that result of the given block is less than expected value. Verification is synchronized with all connected suts.
   # If this method is called for a sut, synchronization is only done with that sut.
   #
   # === params
-  # expected:: Regular expression
+  # expected:: Expected result value of the block
   # timeout:: (optional) Integer defining the amount of seconds during which the verification must pass.
   # message:: (optional) A String that is displayed as additional information if the verification fails.
   # === returns
   # nil
   # === raises
   # ArgumentError:: message was not a String or timeout an integer, or no block was given.
-  # TypeError:: if block result not type of String.
   # VerificationError:: The verification failed.
   # RuntimeError:: An unexpected error was encountered during verification.
-  def verify_regexp( expected_value, timeout = nil, message = nil, &block )
+  def verify_less( expected_value, timeout = nil, message = nil, &block )
   
     begin
 
@@ -742,20 +756,21 @@ module TDriverVerify
       # disable behaviour logging
       $logger.enabled = false
 
-      # ensure that code block was given
-      raise ArgumentError, "No block was given." unless block_given?
-
       # ensure that timeout is either nil or type of integer
-      raise ArgumentError, "wrong argument type #{ timeout.class } for timeout (expected Fixnum or NilClass)" unless [ NilClass, Fixnum ].include?( timeout.class )
+      timeout.check_type [ Integer, NilClass ], 'wrong argument type $1 for timeout (expected $2)'
 
       # ensure that message is either nil or type of string
-      raise ArgumentError, "Argument message was not a String" unless [ NilClass, String ].include?( message.class ) 
+      message.check_type [ String, NilClass ], 'wrong argument type $1 for exception message (expected $2)'
 
-      expected_value.check_type Regexp, "wrong argument type $1 for expected result (expected $2)"
+      # verify that block was given
+      raise LocalJumpError, 'unable to verify due to no code block was given' unless block_given?
 
       # convert timeout to integer, nil will be zero
       timeout = get_timeout( timeout )
 
+      # verify that timeout is valid
+      timeout.not_negative 'timeout value cannot be negative'
+
       # calculate the time when timeout exceeds
       timeout_end_time = Time.now + timeout
 
@@ -783,8 +798,8 @@ module TDriverVerify
           # execute code block
           result = yield
 
-          # raise exception if result of yield does not match with expected value regexp 
-          raise MobyBase::VerificationError unless result =~ expected_value
+          # raise exception if result of yield is less than expected value 
+          raise MobyBase::VerificationError unless result < expected_value
 
           # break loop if no exceptions thrown
           break
@@ -794,7 +809,7 @@ module TDriverVerify
           raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
 
           # refresh and retry unless timeout exceeded
-          raise $! if Time.new > timeout_end_time
+          raise $! if Time.now > timeout_end_time
           
           # retry interval
           sleep TIMEOUT_CYCLE_SECONDS
@@ -822,7 +837,7 @@ module TDriverVerify
       elsif $!.kind_of?( MobyBase::VerificationError )
       
         error_message = "Verification #{ message }at #{ verify_caller } failed: #{ MobyUtil::KernelHelper.find_source( verify_caller ) }"
-        error_message << "The block did not return #{ expected_value.inspect } pattern. It returned: #{ result.inspect }"
+        error_message << "The block did not return #{ expected_value }. It returned: #{ result.inspect }"
         
       else
       
@@ -831,7 +846,7 @@ module TDriverVerify
       
       end
 
-      $logger.behaviour "FAIL;Verification #{ message }failed: #{ $!.to_s }.\n #{ timeout.nil? ? '' : ' using timeout ' + timeout.to_s }.;#{ self.kind_of?( MobyBase::SUT ) ? self.id.to_s + ';sut' : ';' };{};verify_regexp;"
+      $logger.behaviour "FAIL;Verification #{ message }failed: #{ $!.to_s }.\n #{ timeout.nil? ? '' : ' using timeout ' + timeout.to_s }.;#{ self.kind_of?( MobyBase::SUT ) ? self.id.to_s + ';sut' : ';' };{};verify_less;"
 
       # raise the exception
       raise MobyBase::VerificationError, error_message
@@ -846,725 +861,365 @@ module TDriverVerify
     
     end
 
-    $logger.behaviour "PASS;Verification #{ message }at #{ verify_caller } was successful#{ timeout.nil? ? '' : ' using timeout ' + timeout.to_s }.;#{ self.kind_of?( MobyBase::SUT ) ? self.id.to_s + ';sut' : ';' };{};verify_regexp;"
+    $logger.behaviour "PASS;Verification #{ message }at #{ verify_caller } was successful#{ timeout.nil? ? '' : ' using timeout ' + timeout.to_s }.;#{ self.kind_of?( MobyBase::SUT ) ? self.id.to_s + ';sut' : ';' };{};verify_less;"
 
     nil
   
   end
 
-  # Verifies that the given signal is emitted.
-  #
-  # === params
-  # timeout:: Integer, defining the amount of seconds during which the verification must pass.
-  # signal_name:: String, name of the signal
-  # message:: (optional) A String that is displayed as additional information if the verification fails.
-  # block:: code to execute while listening signals
-  # === returns
-  # nil
-  # === raises
-  # ArgumentError:: message or signal_name was not a String or timeout a non negative Integer
-  # VerificationError:: The verification failed.
-  def verify_signal( timeout, signal_name, message = nil, &block )
-
-    logging_enabled = $logger.enabled
-    verify_caller = caller(1).first.to_s
-
-    begin
-
-      $logger.enabled = false
-
-      raise ArgumentError, "Argument timeout was not a non negative Integer." unless (timeout.kind_of?(Integer) && timeout >= 0)
-      raise ArgumentError, "Argument message was not a non empty String." unless (message.nil? || (message.kind_of?(String) && !message.empty?))
-
-      # wait for the signal
-      begin
-
-        self.wait_for_signal( timeout, signal_name, &block )
-
-      rescue
-
-        error_msg = "Verification #{message.nil? ? '' : '"' << message.to_s << '" '}at #{verify_caller} failed:"
-        error_msg << MobyUtil::KernelHelper.find_source(verify_caller)
-        error_msg << "The signal #{signal_name} was not emitted in #{timeout} seconds.\nNested exception:\n" << $!.inspect
-
-        raise MobyBase::VerificationError, error_msg
-
-      end
-
-    rescue
-
-      execute_on_error_verify_block unless @@on_error_verify_block.nil?
-
-      $logger.enabled = logging_enabled
-
-      $logger.behaviour "FAIL;Verification #{message.nil? ? '' : '\"' << message << '\" '}failed: #{$!.to_s} using timeout '#{timeout}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify_signal;#{signal_name}"
-
-      raise
-
-    ensure
-    
-      $logger.enabled = logging_enabled
-      
-    end
-
-    $logger.behaviour "PASS;Verification #{message.nil? ? '' : '\"' << message << '\" '}at #{verify_caller} was successful#{timeout.nil? ? '' : ' using timeout ' + timeout.to_s}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify_signal;#{signal_name}"
-    
-    nil
-
-  end
-
-=begin
-
-  # old implementation:
-
-  # Verifies that the block given to return value matches with expected regular expression pattern. Verification is synchronized with all connected suts.
+  # Verifies that result of the given block is greater than expected value. Verification is synchronized with all connected suts.
   # If this method is called for a sut, synchronization is only done with that sut.
   #
   # === params
-  # expected:: Regular expression
+  # expected:: Expected result value of the block
   # timeout:: (optional) Integer defining the amount of seconds during which the verification must pass.
   # message:: (optional) A String that is displayed as additional information if the verification fails.
   # === returns
   # nil
   # === raises
   # ArgumentError:: message was not a String or timeout an integer, or no block was given.
-  # TypeError:: if block result not type of String.
   # VerificationError:: The verification failed.
   # RuntimeError:: An unexpected error was encountered during verification.
-  def verify_regexp( expected, timeout = nil, message = nil, &block )
-
-    logging_enabled = $logger.enabled
-
-    verify_caller = caller( 1 ).first.to_s
-
+  def verify_greater( expected_value, timeout = nil, message = nil, &block )
+  
     begin
 
-      raise ArgumentError, "No block was given." unless block_given?
+      # determine name of caller method
+      verify_caller = caller( 1 ).first.to_s
 
-      # verify argument types
-      timeout.check_type [ Integer, NilClass ], "wrong argument type $1 for timeout (expected $2)"
-      message.check_type [ String, NilClass ], "wrong argument type $1 for message (expected $2)"
-      expected.check_type Regexp, "wrong argument type $1 for expected result (expected $2)"
+      # store orignal logging state
+      logging_enabled = $logger.enabled
 
+      # disable behaviour logging
       $logger.enabled = false
 
-      #Set the testobject timeout to 0 for the duration of the verify call
-      original_sync_timeout = MobyBase::TestObjectFactory.instance.timeout
-
-      MobyBase::TestObjectFactory.instance.timeout = 0
+      # ensure that timeout is either nil or type of integer
+      timeout.check_type [ Integer, NilClass ], 'wrong argument type $1 for timeout (expected $2)'
 
-      timeout_time = get_end_time( timeout )
+      # ensure that message is either nil or type of string
+      message.check_type [ String, NilClass ], 'wrong argument type $1 for exception message (expected $2)'
 
-      loop do
-      
-        counter = ref_counter
-        
-        # catch errors thrown due to verification results
-        begin
-        
-          # catch errors thrown in the provided block
-          begin 
-          
-            # execute block
-            result = yield
+      # verify that block was given
+      raise LocalJumpError, 'unable to verify due to no code block was given' unless block_given?
 
-          rescue Exception
+      # convert timeout to integer, nil will be zero
+      timeout = get_timeout( timeout )
 
-            raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
+      # verify that timeout is valid
+      timeout.not_negative 'timeout value cannot be negative'
 
-            error_msg = "Verification #{ message.nil? ? '' : '"' << message.to_s << '" '}at #{ verify_caller } failed as an exception was thrown when the verification block was executed."
+      # calculate the time when timeout exceeds
+      timeout_end_time = Time.now + timeout
 
-            error_msg << MobyUtil::KernelHelper.find_source( verify_caller )
+      # convert message to string, nil will be empty string
+      message = message.to_s
 
-            error_msg << "\nDetails: \n#{ $!.inspect }"
+      # add double quotation and trailing whitespace if not empty string
+      message = "#{ message.inspect } " if message.length > 0
 
-            raise MobyBase::VerificationError, error_msg
+      # store original timeout value
+      original_timeout_value = MobyBase::TestObjectFactory.instance.timeout
 
-          end
+      # set the testobject timeout to 0 for the duration of the verify call
+      MobyBase::TestObjectFactory.instance.timeout = 0
 
-          # verify that result value is type of string
-          result.check_type String, "wrong variable type $1 for result (expected $2)" 
-          
-          # result verification
-          unless result =~ expected
+      # result container
+      result = nil
 
-            error_msg = "Verification #{ message.nil? ? '' : '"' << message.to_s << '" '}at #{ verify_caller } failed:"
-            
-            error_msg << MobyUtil::KernelHelper.find_source( verify_caller )
-            
-            error_msg << "\nThe block did not match with pattern #{ expected.inspect }. It returned: #{ result.inspect }" 
+      loop do
+      
+        begin
+        
+          counter = ref_counter
 
-            raise MobyBase::VerificationError, error_msg
+          # execute code block
+          result = yield
 
-          end
+          # raise exception if result of yield is greater than expected value 
+          raise MobyBase::VerificationError unless result > expected_value
 
           # break loop if no exceptions thrown
           break
 
-        rescue MobyBase::VerificationError
-
-          # refresh and retry unless timeout reached
+        rescue 
 
-          raise $! if Time.new > timeout_time
+          raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
 
+          # refresh and retry unless timeout exceeded
+          raise $! if Time.now > timeout_end_time
+          
+          # retry interval
           sleep TIMEOUT_CYCLE_SECONDS
 
+          # refresh suts
           refresh_suts if counter == ref_counter
-          
-        rescue MobyBase::ContinuousVerificationError
-        
-          raise
-
-        rescue TypeError
         
-          raise $!
-          
-        rescue Exception
+        end # begin
+      
+      end # do loop
         
-          raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
-
-          # an unexpected error has occurred
-          raise RuntimeError, "An unexpected error was encountered during verification:\n#{ $!.inspect }"
-
-        end # begin, catch any VerificationErrors
-
-      end # do
-
-    rescue Exception
-
-      execute_on_error_verify_block unless @@on_error_verify_block.nil?
-
-      raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
+    rescue
 
+      # restore logger state
       $logger.enabled = logging_enabled
-            
-      $logger.behaviour "FAIL;Verification #{message.nil? ? '' : '\"' << message << '\" '}failed:#{ $!.to_s }.\n#{ timeout.nil? ? '' : ' using timeout ' + timeout.to_s }.;#{ self.kind_of?( MobyBase::SUT ) ? "#{ self.id.to_s };sut" : ';' };{};verify_regexp;#{ expected.inspect }" 
 
-      raise $!
+      # execute on verification error code block
+      execute_on_error_verify_block unless @@on_error_verify_block.nil?
 
-    ensure
+      # process the exception
+      if $!.kind_of?( MobyBase::ContinuousVerificationError )
+      
+        raise
     
-      MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout
-
-      $logger.enabled = logging_enabled
+      elsif $!.kind_of?( MobyBase::VerificationError )
       
-    end
-
-    $logger.behaviour "PASS;Verification #{ message.nil? ? '' : '\"' << message << '\" ' }at #{ verify_caller } was successful#{ timeout.nil? ? '' : ' using timeout ' + timeout.to_s}.;#{ self.kind_of?( MobyBase::SUT ) ? "#{ self.id.to_s };sut" : ';'};{};verify_regexp;#{ expected.inspect }"
-
-    nil
-
-  end
-
-  # Verifies that the block given to this method evaluates without throwing any exceptions. Verification is synchronized with all connected suts.
-  # If this method is called for a sut, synchronization is only done with that sut.
-  #
-  # === params
-  # timeout:: (optional) Integer defining the amount of seconds during which the verification must pass.
-  # message:: (optional) A String that is displayed as additional information if the verification fails.
-  # === returns
-  # nil
-  # === raises
-  # ArgumentError:: message was not a String or timeout an integer, or no block was given.
-  # VerificationError:: The verification failed.
-  def verify( timeout = nil, message = nil, &block )
-
-    logging_enabled = $logger.enabled
-
-    verify_caller = caller(1).first.to_s
-
-    begin
-
-      $logger.enabled = false
+        error_message = "Verification #{ message }at #{ verify_caller } failed: #{ MobyUtil::KernelHelper.find_source( verify_caller ) }"
+        error_message << "The block did not return #{ expected_value }. It returned: #{ result.inspect }"
+        
+      else
       
-      Kernel::raise ArgumentError.new("No block was given.") unless block_given?
-      Kernel::raise ArgumentError.new("Argument timeout was not an Integer.") unless timeout.nil? or timeout.kind_of?(Integer)
-      Kernel::raise ArgumentError.new("Argument message was not a String.") unless message.nil? or message.kind_of?(String)
-
-      #Set the testobject timeout to 0 for the duration of the verify call
-      original_sync_timeout = MobyBase::TestObjectFactory.instance.timeout
-      MobyBase::TestObjectFactory.instance.timeout = 0
-
-      timeout_time = get_end_time(timeout)
-      #TIMEOUT_CYCLE_SECONDS
-
-      loop do
-
-        counter = ref_counter
-
-        begin # catch errors thrown in the provided block
-
-          yield
-
-          # no error => verification ok
-          break
-
-        rescue Exception => e
-
-          raise if e.kind_of? MobyBase::ContinuousVerificationError
-
-          source_contents = ""
-          error_msg = ""
-
-          if Time.new > timeout_time
-
-            error_msg = "Verification #{message.nil? ? '' : '"' << message.to_s << '" '}at #{verify_caller} failed\n"
-
-            begin
-
-              source_contents = MobyUtil::KernelHelper.find_source(verify_caller)
-
-            rescue Exception
-              # failed to load line from file, do nothing
-              $logger.enabled = logging_enabled
-              $logger.behaviour "WARNING;Failed to load source line: #{e.backtrace.inspect}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify;"
-            end
-
-            if !source_contents.empty?
-              error_msg << source_contents
-            end
-
-            error_msg << "\nNested exception:" << e.message << "\n"
-
-            Kernel::raise MobyBase::VerificationError.new(error_msg)
-
-          end
-
-        end
-
-        sleep TIMEOUT_CYCLE_SECONDS
-
-        refresh_suts if counter == ref_counter
-
-      end # do
-
-    rescue Exception => e
-
-      execute_on_error_verify_block unless @@on_error_verify_block.nil?
-
-      raise if e.kind_of? MobyBase::ContinuousVerificationError
+        error_message = "Verification #{ message }at #{ verify_caller } failed as an exception was thrown when the verification block was executed"
+        error_message << "#{ MobyUtil::KernelHelper.find_source( verify_caller ) }\nDetails: \n#{ $!.inspect }"
+      
+      end
 
-      $logger.enabled = logging_enabled
-      $logger.behaviour "FAIL;Verification #{message.nil? ? '' : '\"' << message << '\" '}failed: #{e.to_s}#{timeout.nil? ? '' : ' using timeout ' + timeout.to_s}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify;"
-      Kernel::raise e
+      $logger.behaviour "FAIL;Verification #{ message }failed: #{ $!.to_s }.\n #{ timeout.nil? ? '' : ' using timeout ' + timeout.to_s }.;#{ self.kind_of?( MobyBase::SUT ) ? self.id.to_s + ';sut' : ';' };{};verify_greater;"
 
+      # raise the exception
+      raise MobyBase::VerificationError, error_message
+       
     ensure
 
-      MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout unless original_sync_timeout.nil?
-
-    end
-
-    $logger.enabled = logging_enabled
-    $logger.behaviour "PASS;Verification #{message.nil? ? '' : '\"' << message << '\" '}at #{verify_caller} was successful#{timeout.nil? ? '' : ' using timeout ' + timeout.to_s}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify;"
-
-    return nil
-
-  end
-
-  # Verifies that the block given to this method throws an exception while being evaluated. Verification is synchronized with all connected suts.
-  # If this method is called for a sut, synchronization is only done with that sut.
-  #
-  # === params
-  # timeout:: (optional) Integer defining the amount of seconds during which the verification must pass.
-  # message:: (optional) A String that is displayed as additional information if the verification fails.
-  # === returns
-  # nil
-  # === raises
-  # ArgumentError:: message was not a String or timeout an integer, or no block was given.
-  # VerificationError:: The verification failed.
-  def verify_not( timeout = nil, message = nil, &block )
-
-    logging_enabled = $logger.enabled
-    verify_caller = caller(1).first.to_s
-    begin
-
-      $logger.enabled = false
-      Kernel::raise ArgumentError.new("No block was given.") unless block_given?
-      Kernel::raise ArgumentError.new("Argument timeout was not an Integer.") unless timeout.nil? or timeout.kind_of?(Integer)
-      Kernel::raise ArgumentError.new("Argument message was not a String.") unless message.nil? or message.kind_of?(String)
-
-      #Set the testobject timeout to 0 for the duration of the verify call
-      original_sync_timeout = MobyBase::TestObjectFactory.instance.timeout
-      MobyBase::TestObjectFactory.instance.timeout = 0
-
-      timeout_time = get_end_time(timeout)
-      #TIMEOUT_CYCLE_SECONDS
-
-      loop do
-        counter = ref_counter
-        artificial_exception_raised = false
-        begin # catch errors thrown in the provided block
-
-          yield
-          artificial_exception_raised = true
-          Kernel::raise "test"
-        rescue Exception => e
-          raise if e.kind_of? MobyBase::ContinuousVerificationError
-
-          source_contents = ""
-          error_msg = ""
-
-          if (!artificial_exception_raised)
-            # an error was encountered => verification ok
-            break
-          end
-
-          if Time.new > timeout_time
-
-            error_msg = "Verification #{message.nil? ? '' : '"' << message.to_s << '" '}at #{verify_caller} failed\n"
-
-            source_contents = MobyUtil::KernelHelper.find_source(verify_caller)
-
-            if !source_contents.empty?
-              error_msg << source_contents
-            end
-
-            Kernel::raise MobyBase::VerificationError.new(error_msg)
-
-          end
-
-          sleep TIMEOUT_CYCLE_SECONDS
-
-          refresh_suts if counter == ref_counter
-
-        end
-
-      end # do
-
-
-    rescue Exception => e
-
-      execute_on_error_verify_block unless @@on_error_verify_block.nil?
-
-      raise if e.kind_of? MobyBase::ContinuousVerificationError
+      # restore original test object factory timeout value 
+      MobyBase::TestObjectFactory.instance.timeout = original_timeout_value
 
+      # restore logger state
       $logger.enabled = logging_enabled
-      $logger.behaviour "FAIL;Verification #{message.nil? ? '' : '\"' << message << '\" '}failed: #{e.to_s}#{timeout.nil? ? '' : ' using timeout ' + timeout.to_s}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify_not;"
-      Kernel::raise e
-
-    ensure
-
-      MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout unless original_sync_timeout.nil?
-
+    
     end
 
-    $logger.enabled = logging_enabled
-    $logger.behaviour "PASS;Verification #{message.nil? ? '' : '\"' << message << '\" '}at #{verify_caller} was successful#{timeout.nil? ? '' : ' using timeout ' + timeout.to_s}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify_not;"
-    return nil
+    $logger.behaviour "PASS;Verification #{ message }at #{ verify_caller } was successful#{ timeout.nil? ? '' : ' using timeout ' + timeout.to_s }.;#{ self.kind_of?( MobyBase::SUT ) ? self.id.to_s + ';sut' : ';' };{};verify_greater;"
 
+    nil
+  
   end
 
-  # Verifies that the block given to this method evaluates to the expected value. Verification is synchronized with all connected suts.
+  # Verifies that the block given to return value matches with expected regular expression pattern. Verification is synchronized with all connected suts.
   # If this method is called for a sut, synchronization is only done with that sut.
   #
   # === params
-  # expected:: Expected result value of the block
+  # expected:: Regular expression
   # timeout:: (optional) Integer defining the amount of seconds during which the verification must pass.
   # message:: (optional) A String that is displayed as additional information if the verification fails.
   # === returns
   # nil
   # === raises
   # ArgumentError:: message was not a String or timeout an integer, or no block was given.
+  # TypeError:: if block result not type of String.
   # VerificationError:: The verification failed.
   # RuntimeError:: An unexpected error was encountered during verification.
-  def verify_equal( expected, timeout = nil, message = nil, &block )
-    logging_enabled = $logger.enabled
-    verify_caller = caller(1).first.to_s
-    begin
-      $logger.enabled = false
-      Kernel::raise ArgumentError.new("No block was given.") unless block_given?
-      Kernel::raise ArgumentError.new("Argument timeout was not an Integer.") unless timeout.nil? or timeout.kind_of?(Integer)
-      Kernel::raise ArgumentError.new("Argument message was not a String.") unless message.nil? or message.kind_of?(String)
-
-      #Set the testobject timeout to 0 for the duration of the verify call
-      original_sync_timeout = MobyBase::TestObjectFactory.instance.timeout
-      MobyBase::TestObjectFactory.instance.timeout = 0
-
-      timeout_time = get_end_time(timeout)
-
-      #TIMEOUT_CYCLE_SECONDS
-
-      loop do
-        counter = ref_counter
-        begin # catch errors thrown due to verification results
-
-          begin # catch errors thrown in the provided block
-            result = yield
-
-          rescue Exception => e
-            raise if e.kind_of? MobyBase::ContinuousVerificationError
-            error_msg = "Verification #{message.nil? ? '' : '"' << message.to_s << '" '}at #{verify_caller} failed as an exception was thrown when the verification block was executed."
-            error_msg << MobyUtil::KernelHelper.find_source(verify_caller)
-            error_msg << "\nDetails: "
-            error_msg << "\n" << e.inspect
-            raise MobyBase::VerificationError.new(error_msg)
-          end
-          if result != expected
-            error_msg = "Verification #{message.nil? ? '' : '"' << message.to_s << '" '}at #{verify_caller} failed:"
-            error_msg << MobyUtil::KernelHelper.find_source(verify_caller)
-            error_msg << "\nThe block did not return #{expected.inspect}. It returned: " << result.inspect
-            raise MobyBase::VerificationError.new(error_msg)
-          end
-          # break loop if no exceptions thrown
-          break
-
-        rescue MobyBase::VerificationError => ve
-
-          # refresh and retry unless timeout reached
-
-          if Time.new > timeout_time
-            Kernel::raise ve
-          end
-
-          sleep TIMEOUT_CYCLE_SECONDS
+  def verify_regexp( expected_value, timeout = nil, message = nil, &block )
 
-          refresh_suts if counter == ref_counter
-        rescue MobyBase::ContinuousVerificationError
-          raise
-        rescue Exception => e
-          raise if e.kind_of? MobyBase::ContinuousVerificationError
-          # an unexpected error has occurred
-          Kernel::raise RuntimeError.new("An unexpected error was encountered during verification:\n" << e.inspect )
+    begin
 
-        end # begin, catch any VerificationErrors
+      # store original timeout value
+      original_timeout_value = MobyBase::TestObjectFactory.instance.timeout
+    
+      # determine name of caller method
+      verify_caller = caller( 1 ).first.to_s
 
-      end # do
+      # store orignal logging state
+      logging_enabled = $logger.enabled
 
-    rescue Exception => e
+      # disable behaviour logging
+      $logger.enabled = false
 
-      execute_on_error_verify_block unless @@on_error_verify_block.nil?
+      # verify that arguments was given in correct format
+      expected_value.check_type Regexp, "wrong argument type $1 for expected result (expected $2)"
 
-      raise if e.kind_of? MobyBase::ContinuousVerificationError
+      # ensure that timeout is either nil or type of integer
+      timeout.check_type [ Integer, NilClass ], 'wrong argument type $1 for timeout (expected $2)'
 
-      $logger.enabled = logging_enabled
-      $logger.behaviour "FAIL;Verification #{message.nil? ? '' : '\"' << message << '\" '}failed:#{e.to_s}.\n#{timeout.nil? ? '' : ' using timeout ' + timeout.to_s}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify_equal;" << expected.to_s
-      Kernel::raise e
-    ensure
-      MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout unless original_sync_timeout.nil?
-    end
+      # ensure that message is either nil or type of string
+      message.check_type [ String, NilClass ], 'wrong argument type $1 for exception message (expected $2)'
+  
+      # verify that block was given
+      raise LocalJumpError, 'unable to verify due to no code block was given' unless block_given?
 
-    $logger.enabled = logging_enabled
-    $logger.behaviour "PASS;Verification #{message.nil? ? '' : '\"' << message << '\" '}at #{verify_caller} was successful#{timeout.nil? ? '' : ' using timeout ' + timeout.to_s}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify_equal;" << expected.to_s
-    return nil
+      # convert timeout to integer, nil will be zero
+      timeout = get_timeout( timeout )
 
-  end
+      # verify that timeout is valid
+      timeout.not_negative 'timeout value cannot be negative'
 
-  # Verifies that the block given to this method evaluates to true. Verification is synchronized with all connected suts.
-  # If this method is called for a sut, synchronization is only done with that sut.
-  #
-  # === params
-  # timeout:: (optional) Integer defining the amount of seconds during which the verification must pass.
-  # message:: (optional) A String that is displayed as additional information if the verification fails.
-  # === returns
-  # nil
-  # === raises
-  # ArgumentError:: message was not a String or timeout an integer, or no block was given.
-  # VerificationError:: The verification failed.
-  # RuntimeError:: An unexpected error was encountered during verification.
-  def verify_true( timeout = nil, message = nil, &block )
+      # calculate the time when timeout exceeds
+      timeout_end_time = Time.now + timeout
 
-    logging_enabled = $logger.enabled
-    verify_caller = caller(1).first.to_s
+      # convert message to string, nil will be empty string
+      message = message.to_s
 
-    begin
-      $logger.enabled = false
-      Kernel::raise ArgumentError.new("No block was given.") unless block_given?
-      Kernel::raise ArgumentError.new("Argument timeout was not an Integer.") unless timeout.nil? or timeout.kind_of?(Integer)
-      Kernel::raise ArgumentError.new("Argument message was not a String.") unless message.nil? or message.kind_of?(String)
+      # add double quotation and trailing whitespace if not empty string
+      message = "#{ message.inspect } " if message.length > 0
 
-      #Set the testobject timeout to 0 for the duration of the verify call
-      original_sync_timeout = MobyBase::TestObjectFactory.instance.timeout
+      # set the testobject timeout to 0 for the duration of the verify call
       MobyBase::TestObjectFactory.instance.timeout = 0
 
-      timeout_time = get_end_time(timeout)
-      #TIMEOUT_CYCLE_SECONDS
+      # result container
+      result = nil
 
       loop do
+      
+        begin
+        
+          counter = ref_counter
 
-        counter = ref_counter
-
-        begin # catch errors thrown due to verification results
-
-
-          begin # catch errors thrown in the provided block
-
-            result = yield
-
-          rescue Exception => e
-
-            #@@on_error_verify_block.call unless @@on_error_verify_block.nil?
-
-            raise if e.kind_of? MobyBase::ContinuousVerificationError
-
-            error_msg = "Verification #{message.nil? ? '' : '"' << message.to_s << '" '}at #{verify_caller} failed as an exception was thrown when the verification block was executed."
-            error_msg << MobyUtil::KernelHelper.find_source(verify_caller)
-            error_msg << "\nDetails: "
-            error_msg << "\n" << e.inspect
-
-            raise MobyBase::VerificationError.new( error_msg )
-
-          end
-
-          unless result == true
-
-            error_msg = "Verification #{message.nil? ? '' : '"' << message.to_s << '" '}at #{verify_caller} failed."
-            error_msg << MobyUtil::KernelHelper.find_source(verify_caller)
-
-            error_msg << "\nThe block did not return true. It returned: " << result.inspect
-
-            raise MobyBase::VerificationError.new( error_msg )
+          # execute code block
+          result = yield
 
-          end
+          # raise exception if result of yield does not match with expected value regexp 
+          raise MobyBase::VerificationError unless result =~ expected_value
 
           # break loop if no exceptions thrown
           break
 
-        rescue MobyBase::VerificationError => ve
-
-          # refresh and retry unless timeout reached
-
-          if ( Time.new > timeout_time )
-
-            execute_on_error_verify_block unless @@on_error_verify_block.nil?
-
-            Kernel::raise ve
+        rescue 
 
-          end
+          raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
 
+          # refresh and retry unless timeout exceeded
+          raise $! if Time.now > timeout_end_time
+          
+          # retry interval
           sleep TIMEOUT_CYCLE_SECONDS
 
+          # refresh suts
           refresh_suts if counter == ref_counter
+        
+        end # begin
+      
+      end # do loop
+        
+    rescue
 
-        rescue Exception => e
+      # restore logger state
+      $logger.enabled = logging_enabled
 
-          raise if e.kind_of? MobyBase::ContinuousVerificationError
+      # execute on verification error code block
+      execute_on_error_verify_block unless @@on_error_verify_block.nil?
 
-          $logger.enabled = logging_enabled
+      # process the exception
+      if $!.kind_of?( MobyBase::ContinuousVerificationError )
+      
+        raise
+    
+      elsif $!.kind_of?( MobyBase::VerificationError )
+      
+        error_message = "Verification #{ message }at #{ verify_caller } failed: #{ MobyUtil::KernelHelper.find_source( verify_caller ) }"
+        error_message << "The return value of block did not match with #{ expected_value.inspect } pattern. Block returned: #{ result.inspect }"
+        
+      else
+      
+        error_message = "Verification #{ message }at #{ verify_caller } failed as an exception was thrown when the verification block was executed"
+        error_message << "#{ MobyUtil::KernelHelper.find_source( verify_caller ) }\nDetails: \n#{ $!.inspect }"
+      
+      end
 
-          # an unexpected error has occurred
-          Kernel::raise RuntimeError.new("An unexpected error was encountered during verification:\n" << e.inspect )
+      $logger.behaviour "FAIL;Verification #{ message }failed: #{ $!.to_s }.\n #{ timeout.nil? ? '' : ' using timeout ' + timeout.to_s }.;#{ self.kind_of?( MobyBase::SUT ) ? self.id.to_s + ';sut' : ';' };{};verify_regexp;"
 
-        end # begin, catch any VerificationErrors
+      # raise the exception
+      raise MobyBase::VerificationError, error_message
+       
+    ensure
 
-      end # do
+      # restore original test object factory timeout value 
+      MobyBase::TestObjectFactory.instance.timeout = original_timeout_value
 
-    rescue Exception => e
-      raise if e.kind_of? MobyBase::ContinuousVerificationError
+      # restore logger state
       $logger.enabled = logging_enabled
-      $logger.behaviour "FAIL;Verification #{message.nil? ? '' : '\"' << message << '\" '}failed:#{e.to_s}.\n#{timeout.nil? ? '' : ' using timeout ' + timeout.to_s}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify_true;"
-      Kernel::raise e
-    ensure
-      MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout unless original_sync_timeout.nil?
+    
     end
 
-    $logger.enabled = logging_enabled
-    $logger.behaviour "PASS;Verification #{message.nil? ? '' : '\"' << message << '\" '}at #{verify_caller} was successful#{timeout.nil? ? '' : ' using timeout ' + timeout.to_s}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify_true;"
-    return nil
+    $logger.behaviour "PASS;Verification #{ message }at #{ verify_caller } was successful#{ timeout.nil? ? '' : ' using timeout ' + timeout.to_s }.;#{ self.kind_of?( MobyBase::SUT ) ? self.id.to_s + ';sut' : ';' };{};verify_regexp;"
 
+    nil
+  
   end
 
-  # Verifies that the block given to this method evaluates to false. Verification is synchronized with all connected suts.
-  # If this method is called for a sut, synchronization is only done with that sut.
+  # Verifies that the given signal is emitted.
   #
   # === params
-  # timeout:: (optional) Integer defining the amount of seconds during which the verification must pass.
+  # timeout:: Integer, defining the amount of seconds during which the verification must pass.
+  # signal_name:: String, name of the signal
   # message:: (optional) A String that is displayed as additional information if the verification fails.
+  # block:: code to execute while listening signals
   # === returns
   # nil
   # === raises
-  # ArgumentError:: message was not a String or timeout an integer, or no block was given.
+  # ArgumentError:: message or signal_name was not a String or timeout a non negative Integer
   # VerificationError:: The verification failed.
-  # RuntimeError:: An unexpected error was encountered during verification.
-  def verify_false( timeout = nil, message = nil, &block )
-
-    logging_enabled = $logger.enabled
-
-    verify_caller = caller(1).first.to_s
+  def verify_signal( timeout, signal_name, message = nil, &block )
 
     begin
 
-      $logger.enabled = false
-
-      Kernel::raise ArgumentError.new("No block was given.") unless block_given?
+      logging_enabled = $logger.enabled
 
-      Kernel::raise ArgumentError.new("Argument timeout was not an Integer.") unless timeout.nil? or timeout.kind_of?(Integer)
-      Kernel::raise ArgumentError.new("Argument message was not a String.") unless message.nil? or message.kind_of?(String)
+      $logger.enabled = false
 
-      #Set the testobject timeout to 0 for the duration of the verify call
-      original_sync_timeout = MobyBase::TestObjectFactory.instance.timeout
-      MobyBase::TestObjectFactory.instance.timeout = 0
+      # ensure that timeout is either nil or type of integer
+      timeout.check_type Integer, 'wrong argument type $1 for timeout (expected $2)'
 
-      timeout_time = get_end_time(timeout)
-      #TIMEOUT_CYCLE_SECONDS
+      # ensure that message is either nil or type of string
+      message.check_type [ String, NilClass ], 'wrong argument type $1 for exception message (expected $2)'
 
-      loop do
-        counter = ref_counter
-        begin # catch errors thrown due to verification results
-
-          begin # catch errors thrown in the provided block
-            result = yield
-          rescue Exception => e
-            raise if e.kind_of? MobyBase::ContinuousVerificationError
-            error_msg = "Verification #{message.nil? ? '' : '"' << message.to_s << '" '}at #{verify_caller} failed as an exception was thrown when the verification block was executed."
-            error_msg << MobyUtil::KernelHelper.find_source(verify_caller)
-            error_msg << "\nDetails: "
-            error_msg << "\n" << e.inspect
-            raise MobyBase::VerificationError.new(error_msg)
-          end
+      # verify that block was given
+      raise LocalJumpError, 'unable to verify due to no code block was given' unless block_given?
 
-          error_msg = "Verification #{message.nil? ? '' : '"' << message.to_s << '" '}at #{verify_caller} failed:"
-          error_msg << MobyUtil::KernelHelper.find_source(verify_caller)
-          error_msg << "The block did not return false. It returned: " << result.inspect
-          raise MobyBase::VerificationError.new(error_msg) unless result == false
+      # verify that timeout is valid
+      timeout.not_negative 'timeout value cannot be negative'
 
-          # break loop if no exceptions thrown
-          break
-
-        rescue MobyBase::VerificationError => ve
+      # convert message to string, nil will be empty string
+      message = message.to_s
 
-          # refresh and retry unless timeout reached
+      # add double quotation and trailing whitespace if not empty string
+      message = "#{ message.inspect } " if message.length > 0
 
-          if Time.new > timeout_time
-            Kernel::raise ve
-          end
+      verify_caller = caller(1).first.to_s
 
-          sleep TIMEOUT_CYCLE_SECONDS
+      # wait for the signal
+      begin
 
-          refresh_suts if counter == ref_counter
+        self.wait_for_signal( timeout, signal_name, &block )
 
+      rescue
 
-        rescue Exception => e
-          raise if e.kind_of? MobyBase::ContinuousVerificationError
-          # an unexpected error has occurred
-          $logger.enabled = logging_enabled
-          Kernel::raise RuntimeError.new("An unexpected error was encountered during verification:\n" << e.inspect )
+        error_msg = "Verification #{ message }at #{ verify_caller } failed: #{ MobyUtil::KernelHelper.find_source(verify_caller) }"
+        error_msg << "The signal #{ signal_name } was not emitted in #{ timeout } seconds.\nNested exception:\n#{ $!.inspect }"
 
-        end # begin, catch any VerificationErrors
+        raise MobyBase::VerificationError, error_msg
 
-      end # do
+      end
 
-    rescue Exception => e
+    rescue
 
       execute_on_error_verify_block unless @@on_error_verify_block.nil?
 
-      raise if e.kind_of? MobyBase::ContinuousVerificationError
-
       $logger.enabled = logging_enabled
-      $logger.behaviour "FAIL;Verification #{message.nil? ? '' : '\"' << message << '\" '}failed:#{e.to_s}.\n #{timeout.nil? ? '' : ' using timeout ' + timeout.to_s}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify_false;"
 
-      Kernel::raise e
+      $logger.behaviour "FAIL;Verification #{ message }failed: #{ $!.to_s } using timeout '#{ timeout }.;#{ self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';' };{};verify_signal;#{ signal_name }"
+
+      raise
 
     ensure
-      MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout unless original_sync_timeout.nil?
+    
+      $logger.enabled = logging_enabled
+      
     end
 
-    $logger.enabled = logging_enabled
-    $logger.behaviour "PASS;Verification #{message.nil? ? '' : '\"' << message << '\" '}at #{verify_caller} was successful#{timeout.nil? ? '' : ' using timeout ' + timeout.to_s}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify_false;"
-    return nil
+    $logger.behaviour "PASS;Verification #{ message }at #{ verify_caller } was successful#{ timeout.nil? ? '' : ' using timeout ' + timeout.to_s }.;#{ self.kind_of?( MobyBase::SUT ) ? self.id.to_s + ';sut' : ';' };{};verify_signal;#{ signal_name }"
+    
+    nil
 
   end
-  
-=end
 
   private
 
@@ -1572,11 +1227,11 @@ module TDriverVerify
 
     if self.kind_of?( MobyBase::SUT )
 
-      Time.new + ( timeout.nil? ? $parameters[ self.sut ][ :synchronization_timeout, '10' ].to_i : timeout.to_i )
+      Time.now + ( timeout.nil? ? $parameters[ self.sut ][ :synchronization_timeout, '10' ].to_i : timeout.to_i )
 
     else
 
-      Time.new + ( timeout.nil? ? $parameters[ :synchronization_timeout, '10' ].to_i : timeout.to_i )
+      Time.now + ( timeout.nil? ? $parameters[ :synchronization_timeout, '10' ].to_i : timeout.to_i )
 
     end
 
@@ -1584,15 +1239,19 @@ module TDriverVerify
 
   def get_timeout( timeout )
   
-    if self.kind_of?( MobyBase::SUT )
+    #if timeout.nil?
+  
+      if self.kind_of?( MobyBase::SUT )
 
-      timeout = $parameters[ self.sut ][ :synchronization_timeout, '10' ].to_i if timeout.nil?
+        timeout = $parameters[ self.sut ][ :synchronization_timeout, '10' ].to_i if timeout.nil?
 
-    else
+      else
 
-      timeout = $parameters[ :synchronization_timeout, '10' ].to_i if timeout.nil?
+        timeout = $parameters[ :synchronization_timeout, '10' ].to_i if timeout.nil?
 
-    end
+      end
+
+    #end
     
     timeout.to_i