testability-driver 1.1.1 → 1.2.1

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

@@ -21,6 +21,25 @@ module MobyUtil
 
   module XML    
 
+    class << self
+    
+    private
+    
+      def initialize_class
+      
+        # empty xml cache hash
+        @document_cache = { :cache => [], :objects => {} }
+
+        # default xml cache buffer size
+        @document_cache_buffer_size = 10
+
+        # set used parser module
+        self.current_parser = MobyUtil::XML::Nokogiri        
+      
+      end
+    
+    end
+
     # Get current XML parser
     # == params
     # == return
@@ -32,6 +51,31 @@ module MobyUtil
 
     end
 
+    # Set XML document cache buffering size, set 0 to disable
+    # == params
+    # == return
+    # Integer:: 
+    # == raises
+    # TypeError::
+    def self.buffer_size=( value )
+    
+      value.check_type Integer, 'wrong argument type $1 for XML cache buffer size (expected $2)' 
+    
+      @document_cache_buffer_size = value
+    
+    end
+
+    # Get current XML document cache buffering size
+    # == params
+    # == return
+    # Integer:: 
+    # == raises
+    def self.buffer_size
+      
+      @document_cache_buffer_size
+    
+    end
+
     # Set XML parser to be used
     # == params
     # Module:: 
@@ -48,20 +92,31 @@ module MobyUtil
 
       # apply parser implementation to abstraction modules
       [ 
-        MobyUtil::XML::Document, 
-        MobyUtil::XML::Element, 
-        MobyUtil::XML::Nodeset, 
-        MobyUtil::XML::Attribute, 
-        MobyUtil::XML::Text, 
-        MobyUtil::XML::Builder,
-        MobyUtil::XML::Comment ].each do | _module |
-          
-          _module.module_exec{ 
-
-            # include parser implementation to abstraction modules 
-            include MobyUtil::KernelHelper.get_constant( "#{ @@parser }::#{ _module.name.split('::').last }") 
-
-          }
+        :Document, 
+        :Element, 
+        :Nodeset, 
+        :Attribute, 
+        :Text, 
+        :Builder,
+        :Comment 
+        
+      ].each do | _module |
+
+        const_get( _module ).module_exec{
+
+          begin      
+
+            # include parser behaviour
+            include @@parser.const_get( _module ) 
+
+          rescue NameError
+
+            # raise proper exception if behaviour module not found
+            raise NotImplementedError, "Required behaviour module #{ @@parser.name }::#{ _module } not found"
+            
+          end
+        
+        }
         
       end
 
@@ -77,21 +132,78 @@ module MobyUtil
     #
     # == params
     # xml_string:: String containing XML  
+    # crc:: Optional CRC16 checksum - used for cache/buffering if given
     # == return
     # Document:: XML document object
+    # Array:: Array containing XML document object and status was it already found from cache
     # == raises
-    def self.parse_string( xml_string )
+    def self.parse_string( xml_string, crc = nil )
 
       begin
 
-        MobyUtil::XML::Document.new( nil ).tap{ | document | 
+        unless crc.nil?
 
-          # parse given string
-          document.xml = document.parse( xml_string ) 
+          [ Document.new( xml_string ), false ]
 
-        }
+        else
 
-      rescue Exception => exception
+          Document.new( xml_string )
+        
+        end
+
+# JKo: disable xml caching for now, need more investigation why tests starts to fail
+=begin
+        unless crc.nil?
+
+          if @document_cache[ :cache ].include?( crc )
+
+            # return cached object and status that object was found from cache
+            [ @document_cache[ :objects ][ crc ], true ]
+
+          else
+  
+            cache_enabled = ( @document_cache_buffer_size > 0 )
+
+            # create new document object with given xml string
+            document = Document.new( xml_string, { :cache_enabled => cache_enabled } )
+
+            # verify that xml caching is enabled
+            if cache_enabled
+
+              # drop olders cached xml object
+              if @document_cache[ :cache ].count == @document_cache_buffer_size
+
+                # remove data object from cache
+                @document_cache[ :objects ].delete( 
+
+                  # take (oldest) first from cache buffer
+                  @document_cache[ :cache ].shift
+
+                )
+
+              end
+
+              # add new xml data object to cache
+              @document_cache[ :cache ] << crc
+
+              # add new xml data object to cache
+              @document_cache[ :objects ][ crc ] = document 
+
+            end
+
+            # return document object and status that object was not found from cache
+            [ document, false ]
+            
+          end
+
+        else
+
+          # create new document object with given xml string - no caching used
+          Document.new( xml_string )
+
+        end
+=end
+      rescue
 
         if $TDRIVER_INITIALIZED == true
         
@@ -133,14 +245,12 @@ module MobyUtil
           end
 
           # raise exception
-          #Kernel::raise MobyUtil::XML::ParseError.new( "%s (%s)%s" % [ exception.message.gsub("\n", ''), exception.class, dump_location ] )
-          Kernel::raise MobyUtil::XML::ParseError, "#{ exception.message.gsub("\n", '') } (#{ exception.class }). #{ dump_location }"
+          Kernel::raise MobyUtil::XML::ParseError, "#{ $!.message.gsub("\n", '') } (#{ $!.class }). #{ dump_location }"
 
         else
         
           # raise exception
-          #Kernel::raise MobyUtil::XML::ParseError.new( "%s (%s)" % [ exception.message.gsub("\n", ''), exception.class ] )
-          Kernel::raise MobyUtil::XML::ParseError, "#{ exception.message.gsub("\n", '') } (#{ exception.class })"
+          Kernel::raise MobyUtil::XML::ParseError, "#{ $!.message.gsub("\n", '') } (#{ $!.class })"
         
         end
 
@@ -160,11 +270,16 @@ module MobyUtil
     # == raises
     # IOError:: File '%s' not found    
     def self.parse_file( filename )    
-
+  
       # raise exception if file not found
       Kernel::raise IOError, "File #{ filename.inspect } not found" unless File.exist?( filename )
 
-      self.parse_string( IO.read( filename ) )
+      # parse file content
+      parse_string( 
+      
+        IO.read( filename ) 
+        
+      )
 
     end
 
@@ -190,15 +305,15 @@ module MobyUtil
 
       begin
 
-        MobyUtil::XML::Builder.new.tap{ | builder | 
+        Builder.new.tap{ | builder | 
 
           builder.build( &block )
 
         }
 
-      rescue Exception => exception
+      rescue
 
-        Kernel::raise MobyUtil::XML::BuilderError, "#{ exception.message } (#{ exception.class })"
+        Kernel::raise MobyUtil::XML::BuilderError, "#{ $!.message } (#{ $!.class })"
 
       end
       
@@ -207,9 +322,9 @@ module MobyUtil
     # enable hooking for performance measurement & debug logging
     TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
+    # initialize class
+    initialize_class
+
   end # XML
 
 end # MobyUtil
-
-# set used parser module
-MobyUtil::XML.current_parser = MobyUtil::XML::Nokogiri

data/lib/tdriver/verify/verify.rb

@@ -45,15 +45,15 @@ module TDriverVerify
 
         @@on_error_verify_block.call
 
-      rescue Exception => exception
+      rescue Exception
 
-        raise exception.class.new( "Exception was raised while executing on_error_verify_block. Reason: %s" % [ exception.message ])
+        raise exception.class, "Exception was raised while executing on_error_verify_block. Reason: #{ $!.message.to_s }"
 
       end
 
     else
 
-      raise ArgumentError.new( "No verify block defined with on_error_verify_block method" )
+      raise ArgumentError, 'No verify block defined with on_error_verify_block method'
 
     end
 
@@ -70,103 +70,993 @@ module TDriverVerify
   # === 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 )
+  
+    begin
+
+      # determine name of caller method
+      verify_caller = caller( 1 ).first.to_s
+
+      # store orignal logging state
+      logging_enabled = $logger.enabled
+
+      # 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 )
+
+      # ensure that message is either nil or type of string
+      raise ArgumentError, "Argument message was not a String" unless [ NilClass, String ].include?( message.class ) 
+
+      # convert timeout to integer, nil will be zero
+      timeout = get_timeout( timeout )
+
+      # calculate the time when timeout exceeds
+      timeout_end_time = Time.now + timeout
+
+      # convert message to string, nil will be empty string
+      message = message.to_s
+
+      # add double quotation and trailing whitespace if not empty string
+      message = "#{ message.inspect } " if message.length > 0
+
+      # store original timeout value
+      original_timeout_value = MobyBase::TestObjectFactory.instance.timeout
+
+      # set the testobject timeout to 0 for the duration of the verify call
+      MobyBase::TestObjectFactory.instance.timeout = 0
+
+      loop do
+      
+        begin
+        
+          counter = ref_counter
+
+          # execute code block
+          yield
+
+          # break loop if no exceptions thrown
+          break
+
+        rescue 
+
+          raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
+
+          # refresh and retry unless timeout exceeded
+          raise $! if Time.new > timeout_end_time
+          
+          # retry interval
+          sleep TIMEOUT_CYCLE_SECONDS
+
+          # refresh suts
+          refresh_suts if counter == ref_counter
+        
+        end # begin
+      
+      end # do loop
+        
+    rescue
+
+      # restore logger state
+      $logger.enabled = logging_enabled
+
+      # execute on verification error code block
+      execute_on_error_verify_block unless @@on_error_verify_block.nil?
+
+      # process the exception
+      if $!.kind_of?( MobyBase::ContinuousVerificationError )
+      
+        raise
+            
+      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
+
+      $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;"
+
+      # raise the exception
+      raise MobyBase::VerificationError, error_message
+       
+    ensure
+
+      # restore original test object factory timeout value 
+      MobyBase::TestObjectFactory.instance.timeout = original_timeout_value
+
+      # restore logger state
+      $logger.enabled = logging_enabled
+    
+    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;"
+
+    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 )
+  
+    begin
+
+      # determine name of caller method
+      verify_caller = caller( 1 ).first.to_s
+
+      # store orignal logging state
+      logging_enabled = $logger.enabled
+
+      # 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 )
+
+      # ensure that message is either nil or type of string
+      raise ArgumentError, "Argument message was not a String" unless [ NilClass, String ].include?( message.class ) 
+
+      # convert timeout to integer, nil will be zero
+      timeout = get_timeout( timeout )
+
+      # calculate the time when timeout exceeds
+      timeout_end_time = Time.now + timeout
+
+      # convert message to string, nil will be empty string
+      message = message.to_s
+
+      # add double quotation and trailing whitespace if not empty string
+      message = "#{ message.inspect } " if message.length > 0
+
+      # store original timeout value
+      original_timeout_value = MobyBase::TestObjectFactory.instance.timeout
+
+      # set the testobject timeout to 0 for the duration of the verify call
+      MobyBase::TestObjectFactory.instance.timeout = 0
+
+      # result container
+      result = nil
+
+      loop do
+      
+        counter = ref_counter
+
+        begin
+        
+          # execute code block
+          result = yield
+
+        rescue
+
+          raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
+        
+          # break loop if exceptions thrown
+          break
+
+        end
+
+        # refresh and retry unless timeout exceeded
+        raise $! if Time.new > timeout_end_time
+        
+        # retry interval
+        sleep TIMEOUT_CYCLE_SECONDS
+
+        # refresh suts
+        refresh_suts if counter == ref_counter
+      
+      end # do loop
+        
+    rescue
+
+      # restore logger state
+      $logger.enabled = logging_enabled
+
+      # execute on verification error code block
+      execute_on_error_verify_block unless @@on_error_verify_block.nil?
+
+      # 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 block did not raise exception. It 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
+
+      $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_not;"
+
+      # raise the exception
+      raise MobyBase::VerificationError, error_message
+       
+    ensure
+
+      # restore original test object factory timeout value 
+      MobyBase::TestObjectFactory.instance.timeout = original_timeout_value
+
+      # restore logger state
+      $logger.enabled = logging_enabled
+    
+    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_not;"
+
+    nil
+  
+  end
+
+  # 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 )
+  
+    begin
+
+      # expected result
+      expected_value = true
+
+      # determine name of caller method
+      verify_caller = caller( 1 ).first.to_s
+
+      # store orignal logging state
+      logging_enabled = $logger.enabled
+
+      # 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 )
+
+      # ensure that message is either nil or type of string
+      raise ArgumentError, "Argument message was not a String" unless [ NilClass, String ].include?( message.class ) 
+
+      # convert timeout to integer, nil will be zero
+      timeout = get_timeout( timeout )
+
+      # calculate the time when timeout exceeds
+      timeout_end_time = Time.now + timeout
+
+      # convert message to string, nil will be empty string
+      message = message.to_s
+
+      # add double quotation and trailing whitespace if not empty string
+      message = "#{ message.inspect } " if message.length > 0
+
+      # store original timeout value
+      original_timeout_value = MobyBase::TestObjectFactory.instance.timeout
+
+      # set the testobject timeout to 0 for the duration of the verify call
+      MobyBase::TestObjectFactory.instance.timeout = 0
+
+      # result container
+      result = nil
+
+      loop do
+      
+        begin
+        
+          counter = ref_counter
+
+          # execute code block
+          result = yield
+
+          # raise exception if result of yield does not equal with expected value 
+          raise MobyBase::VerificationError unless result == expected_value
+
+          # break loop if no exceptions thrown
+          break
+
+        rescue 
+
+          raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
+
+          # refresh and retry unless timeout exceeded
+          raise $! if Time.new > timeout_end_time
+          
+          # retry interval
+          sleep TIMEOUT_CYCLE_SECONDS
+
+          # refresh suts
+          refresh_suts if counter == ref_counter
+        
+        end # begin
+      
+      end # do loop
+        
+    rescue
+
+      # restore logger state
+      $logger.enabled = logging_enabled
+
+      # execute on verification error code block
+      execute_on_error_verify_block unless @@on_error_verify_block.nil?
+
+      # 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 block did not return #{ expected_value }. It 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
+
+      $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_true;"
+
+      # raise the exception
+      raise MobyBase::VerificationError, error_message
+       
+    ensure
+
+      # restore original test object factory timeout value 
+      MobyBase::TestObjectFactory.instance.timeout = original_timeout_value
+
+      # restore logger state
+      $logger.enabled = logging_enabled
+    
+    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_true;"
+
+    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.
+  #
+  # === 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_false( timeout = nil, message = nil, &block )
+  
+    begin
+
+      # expected result
+      expected_value = false
+
+      # determine name of caller method
+      verify_caller = caller( 1 ).first.to_s
+
+      # store orignal logging state
+      logging_enabled = $logger.enabled
+
+      # 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 )
+
+      # ensure that message is either nil or type of string
+      raise ArgumentError, "Argument message was not a String" unless [ NilClass, String ].include?( message.class ) 
+
+      # convert timeout to integer, nil will be zero
+      timeout = get_timeout( timeout )
+
+      # calculate the time when timeout exceeds
+      timeout_end_time = Time.now + timeout
+
+      # convert message to string, nil will be empty string
+      message = message.to_s
+
+      # add double quotation and trailing whitespace if not empty string
+      message = "#{ message.inspect } " if message.length > 0
+
+      # store original timeout value
+      original_timeout_value = MobyBase::TestObjectFactory.instance.timeout
+
+      # set the testobject timeout to 0 for the duration of the verify call
+      MobyBase::TestObjectFactory.instance.timeout = 0
+
+      # result container
+      result = nil
+
+      loop do
+      
+        begin
+        
+          counter = ref_counter
+
+          # execute code block
+          result = yield
+
+          # raise exception if result of yield does not equal with expected value 
+          raise MobyBase::VerificationError unless result == expected_value
+
+          # break loop if no exceptions thrown
+          break
+
+        rescue 
+
+          raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
+
+          # refresh and retry unless timeout exceeded
+          raise $! if Time.new > timeout_end_time
+          
+          # retry interval
+          sleep TIMEOUT_CYCLE_SECONDS
+
+          # refresh suts
+          refresh_suts if counter == ref_counter
+        
+        end # begin
+      
+      end # do loop
+        
+    rescue
+
+      # restore logger state
+      $logger.enabled = logging_enabled
+
+      # execute on verification error code block
+      execute_on_error_verify_block unless @@on_error_verify_block.nil?
+
+      # 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 block did not return #{ expected_value }. It 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
+
+      $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_false;"
+
+      # raise the exception
+      raise MobyBase::VerificationError, error_message
+       
+    ensure
+
+      # restore original test object factory timeout value 
+      MobyBase::TestObjectFactory.instance.timeout = original_timeout_value
+
+      # restore logger state
+      $logger.enabled = logging_enabled
+    
+    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_false;"
+
+    nil
+  
+  end
+
+  # Verifies that the block given to this method evaluates to the 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:: 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.
+  # VerificationError:: The verification failed.
+  # RuntimeError:: An unexpected error was encountered during verification.
+  def verify_equal( expected_value, timeout = nil, message = nil, &block )
+  
+    begin
+
+      # determine name of caller method
+      verify_caller = caller( 1 ).first.to_s
+
+      # store orignal logging state
+      logging_enabled = $logger.enabled
+
+      # 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 )
+
+      # ensure that message is either nil or type of string
+      raise ArgumentError, "Argument message was not a String" unless [ NilClass, String ].include?( message.class ) 
+
+      # convert timeout to integer, nil will be zero
+      timeout = get_timeout( timeout )
+
+      # calculate the time when timeout exceeds
+      timeout_end_time = Time.now + timeout
+
+      # convert message to string, nil will be empty string
+      message = message.to_s
+
+      # add double quotation and trailing whitespace if not empty string
+      message = "#{ message.inspect } " if message.length > 0
+
+      # store original timeout value
+      original_timeout_value = MobyBase::TestObjectFactory.instance.timeout
+
+      # set the testobject timeout to 0 for the duration of the verify call
+      MobyBase::TestObjectFactory.instance.timeout = 0
+
+      # result container
+      result = nil
+
+      loop do
+      
+        begin
+        
+          counter = ref_counter
+
+          # execute code block
+          result = yield
+
+          # raise exception if result of yield does not equal with expected value 
+          raise MobyBase::VerificationError unless result == expected_value
+
+          # break loop if no exceptions thrown
+          break
+
+        rescue 
+
+          raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
+
+          # refresh and retry unless timeout exceeded
+          raise $! if Time.new > timeout_end_time
+          
+          # retry interval
+          sleep TIMEOUT_CYCLE_SECONDS
+
+          # refresh suts
+          refresh_suts if counter == ref_counter
+        
+        end # begin
+      
+      end # do loop
+        
+    rescue
+
+      # restore logger state
+      $logger.enabled = logging_enabled
+
+      # execute on verification error code block
+      execute_on_error_verify_block unless @@on_error_verify_block.nil?
+
+      # 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 block did not return #{ expected_value }. It 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
+
+      $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_equal;"
+
+      # raise the exception
+      raise MobyBase::VerificationError, error_message
+       
+    ensure
+
+      # restore original test object factory timeout value 
+      MobyBase::TestObjectFactory.instance.timeout = original_timeout_value
+
+      # restore logger state
+      $logger.enabled = logging_enabled
+    
+    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_equal;"
+
+    nil
+  
+  end
+
+  # 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:: 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_regexp( expected_value, timeout = nil, message = nil, &block )
+  
+    begin
+
+      # determine name of caller method
+      verify_caller = caller( 1 ).first.to_s
+
+      # store orignal logging state
+      logging_enabled = $logger.enabled
+
+      # 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 )
+
+      # ensure that message is either nil or type of string
+      raise ArgumentError, "Argument message was not a String" unless [ NilClass, String ].include?( message.class ) 
+
+      expected_value.check_type Regexp, "wrong argument type $1 for expected result (expected $2)"
+
+      # convert timeout to integer, nil will be zero
+      timeout = get_timeout( timeout )
+
+      # calculate the time when timeout exceeds
+      timeout_end_time = Time.now + timeout
+
+      # convert message to string, nil will be empty string
+      message = message.to_s
+
+      # add double quotation and trailing whitespace if not empty string
+      message = "#{ message.inspect } " if message.length > 0
+
+      # store original timeout value
+      original_timeout_value = MobyBase::TestObjectFactory.instance.timeout
+
+      # set the testobject timeout to 0 for the duration of the verify call
+      MobyBase::TestObjectFactory.instance.timeout = 0
+
+      # result container
+      result = nil
+
+      loop do
+      
+        begin
+        
+          counter = ref_counter
+
+          # 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
+
+          # break loop if no exceptions thrown
+          break
+
+        rescue 
+
+          raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
+
+          # refresh and retry unless timeout exceeded
+          raise $! if Time.new > timeout_end_time
+          
+          # retry interval
+          sleep TIMEOUT_CYCLE_SECONDS
+
+          # refresh suts
+          refresh_suts if counter == ref_counter
+        
+        end # begin
+      
+      end # do loop
+        
+    rescue
+
+      # restore logger state
+      $logger.enabled = logging_enabled
+
+      # execute on verification error code block
+      execute_on_error_verify_block unless @@on_error_verify_block.nil?
+
+      # 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 block did not return #{ expected_value.inspect } pattern. It 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
+
+      $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;"
+
+      # raise the exception
+      raise MobyBase::VerificationError, error_message
+       
+    ensure
+
+      # restore original test object factory timeout value 
+      MobyBase::TestObjectFactory.instance.timeout = original_timeout_value
+
+      # restore logger state
+      $logger.enabled = logging_enabled
+    
+    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;"
+
+    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
 
-  def verify( timeout = nil, message = nil, &block )
+    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.
+  # If this method is called for a sut, synchronization is only done with that sut.
+  #
+  # === params
+  # 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_regexp( expected, timeout = nil, message = nil, &block )
 
     logging_enabled = $logger.enabled
 
-    verify_caller = caller(1).first.to_s
+    verify_caller = caller( 1 ).first.to_s
 
     begin
 
+      raise ArgumentError, "No block was given." unless block_given?
+
+      # 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)"
+
       $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
+      timeout_time = get_end_time( timeout )
 
       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
 
-        begin # catch errors thrown in the provided block
+          rescue Exception
 
-          yield
+            raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
 
-          # no error => verification ok
-          break
+            error_msg = "Verification #{ message.nil? ? '' : '"' << message.to_s << '" '}at #{ verify_caller } failed as an exception was thrown when the verification block was executed."
 
-        rescue Exception => e
+            error_msg << MobyUtil::KernelHelper.find_source( verify_caller )
 
-          raise if e.kind_of? MobyBase::ContinuousVerificationError
+            error_msg << "\nDetails: \n#{ $!.inspect }"
 
-          source_contents = ""
-          error_msg = ""
+            raise MobyBase::VerificationError, error_msg
 
-          if Time.new > timeout_time
+          end
 
-            error_msg = "Verification #{message.nil? ? '' : '"' << message.to_s << '" '}at #{verify_caller} failed\n"
+          # 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
 
-            begin
+            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 }" 
 
-              source_contents = MobyUtil::KernelHelper.find_source(verify_caller)
+            raise MobyBase::VerificationError, error_msg
 
-            rescue Exception
-              # failed to load line from file, do nothing
-              $logger.enabled = logging_enabled
-              $logger.log "behaviour" , "WARNING;Failed to load source line: #{e.backtrace.inspect}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify;"
-            end
+          end
 
-            if !source_contents.empty?
-              error_msg << source_contents
-            end
+          # break loop if no exceptions thrown
+          break
 
-            error_msg << "\nNested exception:" << e.message << "\n"
+        rescue MobyBase::VerificationError
 
-            Kernel::raise MobyBase::VerificationError.new(error_msg)
+          # refresh and retry unless timeout reached
 
-          end
+          raise $! if Time.new > timeout_time
 
-        end
+          sleep TIMEOUT_CYCLE_SECONDS
 
-        sleep TIMEOUT_CYCLE_SECONDS
+          refresh_suts if counter == ref_counter
+          
+        rescue MobyBase::ContinuousVerificationError
+        
+          raise
 
-        refresh_suts if counter == ref_counter
+        rescue TypeError
+        
+          raise $!
+          
+        rescue Exception
+        
+          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 => e
+    rescue Exception
 
       execute_on_error_verify_block unless @@on_error_verify_block.nil?
 
-      raise if e.kind_of? MobyBase::ContinuousVerificationError
+      raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
 
       $logger.enabled = logging_enabled
-      $logger.log "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.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 }" 
 
-    ensure
+      raise $!
 
-      MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout unless original_sync_timeout.nil?
+    ensure
+    
+      MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout
 
+      $logger.enabled = logging_enabled
+      
     end
 
-    $logger.enabled = logging_enabled
-    $logger.log "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;"
+    $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 }"
 
-    return nil
+    nil
 
   end
 
-
-  # Verifies that the block given to this method throws an exception while being evaluated. Verification is synchronized with all connected suts.
+  # 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
@@ -177,13 +1067,16 @@ module TDriverVerify
   # === 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 )
+  def verify( 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)
@@ -196,47 +1089,55 @@ module TDriverVerify
       #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"
+
+          # no error => verification ok
+          break
+
         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)
+            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
 
-          sleep TIMEOUT_CYCLE_SECONDS
+        end
 
-          refresh_suts if counter == ref_counter
+        sleep TIMEOUT_CYCLE_SECONDS
 
-        end
+        refresh_suts if counter == ref_counter
 
       end # do
 
-
     rescue Exception => e
 
       execute_on_error_verify_block unless @@on_error_verify_block.nil?
@@ -244,7 +1145,7 @@ module TDriverVerify
       raise if e.kind_of? MobyBase::ContinuousVerificationError
 
       $logger.enabled = logging_enabled
-      $logger.log "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;"
+      $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
 
     ensure
@@ -254,12 +1155,13 @@ module TDriverVerify
     end
 
     $logger.enabled = logging_enabled
-    $logger.log "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;"
+    $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 evaluates to true. Verification is synchronized with all connected suts.
+  # 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
@@ -270,13 +1172,12 @@ module TDriverVerify
   # === 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 )
+  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)
@@ -290,93 +1191,74 @@ module TDriverVerify
       #TIMEOUT_CYCLE_SECONDS
 
       loop do
-
         counter = ref_counter
+        artificial_exception_raised = false
+        begin # catch errors thrown in the provided block
 
-        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
+          yield
+          artificial_exception_raised = true
+          Kernel::raise "test"
+        rescue Exception => e
+          raise if e.kind_of? MobyBase::ContinuousVerificationError
 
-            raise MobyBase::VerificationError.new( error_msg )
+          source_contents = ""
+          error_msg = ""
 
+          if (!artificial_exception_raised)
+            # an error was encountered => verification ok
+            break
           end
 
-          # 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
+          if Time.new > timeout_time
 
-          end
+            error_msg = "Verification #{message.nil? ? '' : '"' << message.to_s << '" '}at #{verify_caller} failed\n"
 
-          sleep TIMEOUT_CYCLE_SECONDS
+            source_contents = MobyUtil::KernelHelper.find_source(verify_caller)
 
-          refresh_suts if counter == ref_counter
+            if !source_contents.empty?
+              error_msg << source_contents
+            end
 
-        rescue Exception => e
+            Kernel::raise MobyBase::VerificationError.new(error_msg)
 
-          raise if e.kind_of? MobyBase::ContinuousVerificationError
+          end
 
-          $logger.enabled = logging_enabled
+          sleep TIMEOUT_CYCLE_SECONDS
 
-          # an unexpected error has occurred
-          Kernel::raise RuntimeError.new("An unexpected error was encountered during verification:\n" << e.inspect )
+          refresh_suts if counter == ref_counter
 
-        end # begin, catch any VerificationErrors
+        end
 
       end # do
 
+
     rescue Exception => e
+
+      execute_on_error_verify_block unless @@on_error_verify_block.nil?
+
       raise if e.kind_of? MobyBase::ContinuousVerificationError
+
       $logger.enabled = logging_enabled
-      $logger.log "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;"
+      $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.log "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;"
+    $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
 
   end
 
-  # Verifies that the block given to this method evaluates to false. Verification is synchronized with all connected suts.
+  # Verifies that the block given to this method evaluates to the 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:: 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
@@ -385,18 +1267,12 @@ module TDriverVerify
   # 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_false( timeout = nil, message = nil, &block )
-
+  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)
 
@@ -405,6 +1281,7 @@ module TDriverVerify
       MobyBase::TestObjectFactory.instance.timeout = 0
 
       timeout_time = get_end_time(timeout)
+
       #TIMEOUT_CYCLE_SECONDS
 
       loop do
@@ -413,6 +1290,7 @@ module TDriverVerify
 
           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."
@@ -421,12 +1299,12 @@ module TDriverVerify
             error_msg << "\n" << e.inspect
             raise MobyBase::VerificationError.new(error_msg)
           end
-
-          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
-
+          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
 
@@ -441,12 +1319,11 @@ module TDriverVerify
           sleep TIMEOUT_CYCLE_SECONDS
 
           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
-          $logger.enabled = logging_enabled
           Kernel::raise RuntimeError.new("An unexpected error was encountered during verification:\n" << e.inspect )
 
         end # begin, catch any VerificationErrors
@@ -460,25 +1337,22 @@ module TDriverVerify
       raise if e.kind_of? MobyBase::ContinuousVerificationError
 
       $logger.enabled = logging_enabled
-      $logger.log "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;"
-
+      $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
 
     $logger.enabled = logging_enabled
-    $logger.log "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;"
+    $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
 
   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 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
-  # 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
@@ -487,9 +1361,11 @@ module TDriverVerify
   # 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_equal( expected, timeout = nil, message = nil, &block )
+  def verify_true( 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?
@@ -501,30 +1377,45 @@ module TDriverVerify
       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
+
+            #@@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)
+
+            raise MobyBase::VerificationError.new( error_msg )
+
           end
-          if result != expected
-            error_msg = "Verification #{message.nil? ? '' : '"' << message.to_s << '" '}at #{verify_caller} failed:"
+
+          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 #{expected.inspect}. It returned: " << result.inspect
-            raise MobyBase::VerificationError.new(error_msg)
+
+            error_msg << "\nThe block did not return true. It returned: " << result.inspect
+
+            raise MobyBase::VerificationError.new( error_msg )
+
           end
+
           # break loop if no exceptions thrown
           break
 
@@ -532,17 +1423,24 @@ module TDriverVerify
 
           # refresh and retry unless timeout reached
 
-          if Time.new > timeout_time
+          if ( Time.new > timeout_time )
+
+            execute_on_error_verify_block unless @@on_error_verify_block.nil?
+
             Kernel::raise ve
+
           end
 
           sleep TIMEOUT_CYCLE_SECONDS
 
           refresh_suts if counter == ref_counter
-        rescue MobyBase::ContinuousVerificationError
-          raise
+
         rescue Exception => e
+
           raise if e.kind_of? MobyBase::ContinuousVerificationError
+
+          $logger.enabled = logging_enabled
+
           # an unexpected error has occurred
           Kernel::raise RuntimeError.new("An unexpected error was encountered during verification:\n" << e.inspect )
 
@@ -551,228 +1449,153 @@ module TDriverVerify
       end # do
 
     rescue Exception => e
-
-      execute_on_error_verify_block unless @@on_error_verify_block.nil?
-
       raise if e.kind_of? MobyBase::ContinuousVerificationError
-
       $logger.enabled = logging_enabled
-      $logger.log "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
+      $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.log "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
+    $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
 
   end
 
-  # Verifies that the block given to return value matches with expected regular expression pattern. Verification is synchronized with all connected suts.
+  # 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.
   #
   # === params
-  # 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_regexp( expected, timeout = nil, message = nil, &block )
+  def verify_false( timeout = nil, message = nil, &block )
 
     logging_enabled = $logger.enabled
 
-    verify_caller = caller( 1 ).first.to_s
+    verify_caller = caller(1).first.to_s
 
     begin
 
-      raise ArgumentError, "No block was given." unless block_given?
+      $logger.enabled = false
 
-      # 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)"
+      Kernel::raise ArgumentError.new("No block was given.") unless block_given?
 
-      $logger.enabled = false
+      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_time = get_end_time(timeout)
+      #TIMEOUT_CYCLE_SECONDS
 
       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
-
-          rescue Exception
-
-            raise if $!.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: \n#{ $!.inspect }"
-
-            raise MobyBase::VerificationError, error_msg
+        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 result value is type of string
-          result.check_type String, "wrong variable type $1 for result (expected $2)" 
-          
-          # result verification
-          unless 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 match with pattern #{ expected.inspect }. It returned: #{ result.inspect }" 
-
-            raise MobyBase::VerificationError, error_msg
-
-          end
+          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
 
           # break loop if no exceptions thrown
           break
 
-        rescue MobyBase::VerificationError
+        rescue MobyBase::VerificationError => ve
 
           # refresh and retry unless timeout reached
 
-          raise $! if Time.new > timeout_time
+          if Time.new > timeout_time
+            Kernel::raise ve
+          end
 
           sleep TIMEOUT_CYCLE_SECONDS
 
           refresh_suts if counter == ref_counter
-          
-        rescue MobyBase::ContinuousVerificationError
-        
-          raise
 
-        rescue TypeError
-        
-          raise $!
-          
-        rescue Exception
-        
-          raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
 
+        rescue Exception => e
+          raise if e.kind_of? MobyBase::ContinuousVerificationError
           # an unexpected error has occurred
-          raise RuntimeError, "An unexpected error was encountered during verification:\n#{ $!.inspect }"
+          $logger.enabled = logging_enabled
+          Kernel::raise RuntimeError.new("An unexpected error was encountered during verification:\n" << e.inspect )
 
         end # begin, catch any VerificationErrors
 
       end # do
 
-    rescue Exception
+    rescue Exception => e
 
       execute_on_error_verify_block unless @@on_error_verify_block.nil?
 
-      raise if $!.kind_of?( MobyBase::ContinuousVerificationError )
+      raise if e.kind_of? MobyBase::ContinuousVerificationError
 
       $logger.enabled = logging_enabled
-            
-      $logger.log "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 }" 
+      $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;"
 
-      raise $!
+      Kernel::raise e
 
     ensure
-    
-      MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout
-
-      $logger.enabled = logging_enabled
-      
+      MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout unless original_sync_timeout.nil?
     end
 
-    $logger.log "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
+    $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
 
   end
+  
+=end
 
+  private
 
-  # 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
-
-      Kernel::raise ArgumentError.new("Argument timeout was not a non negative Integer.") unless (timeout.kind_of?(Integer) && timeout >= 0)
-      Kernel::raise ArgumentError.new("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 Exception => e
+  def get_end_time( timeout )
 
-        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."
-        error_msg << "\nNested exception:\n" << e.inspect
-        Kernel::raise MobyBase::VerificationError.new(error_msg)
+    if self.kind_of?( MobyBase::SUT )
 
-      end
+      Time.new + ( timeout.nil? ? $parameters[ self.sut ][ :synchronization_timeout, '10' ].to_i : timeout.to_i )
 
-    rescue Exception => e
+    else
 
-      execute_on_error_verify_block unless @@on_error_verify_block.nil?
+      Time.new + ( timeout.nil? ? $parameters[ :synchronization_timeout, '10' ].to_i : timeout.to_i )
 
-      $logger.enabled = logging_enabled
-      $logger.log "behaviour" , "FAIL;Verification #{message.nil? ? '' : '\"' << message << '\" '}failed: #{e.to_s} using timeout '#{timeout}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify_signal;#{signal_name}"
-      Kernel::raise e
     end
 
-    $logger.enabled = logging_enabled
-    $logger.log "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}"
-    return nil
-
   end
 
-  private
-
+  def get_timeout( timeout )
+  
+    if self.kind_of?( MobyBase::SUT )
 
-  def get_end_time(timeout)
+      timeout = $parameters[ self.sut ][ :synchronization_timeout, '10' ].to_i if timeout.nil?
 
-    if self.kind_of?(MobyBase::SUT)
-      Time.new + (timeout.nil? ? MobyUtil::Parameter[self.sut][ :synchronization_timeout].to_i : timeout.to_i)
     else
-      Time.new + (timeout.nil? ? MobyUtil::Parameter[ :synchronization_timeout].to_i : timeout.to_i)
+
+      timeout = $parameters[ :synchronization_timeout, '10' ].to_i if timeout.nil?
+
     end
+    
+    timeout.to_i
+      
   end
 
   # Current count of combined sut refresh calls to all suts