testability-driver 1.0.3 → 1.0.4

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

@@ -117,7 +117,6 @@ module MobyUtil
           @xml.empty?
 
         end
-
         
         def length
 
@@ -188,7 +187,7 @@ module MobyUtil
         end
 
         # enable hooking for performance measurement & debug logging
-        MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+        TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
       end # Nodeset
 

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

@@ -25,28 +25,10 @@ module MobyUtil
 
       module Text # behaviour
 
-        include Abstraction 
-
-        def parent
-        
-          element_object( @xml.parent )
-        
-        end
-
-        def to_s
-  
-          @xml.content
-
-        end
-
-        def content
-
-          @xml.content
-
-        end
+        include Node
 
         # enable hooking for performance measurement & debug logging
-        MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+        TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
       end # Element
 

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

@@ -21,10 +21,6 @@ module MobyUtil
 
   module XML    
 
-    # default values
-    #@@parser = MobyUtil::XML::LibXML 
-    @@parser = MobyUtil::XML::Nokogiri
-
     # Get current XML parser
     # == params
     # == return
@@ -45,9 +41,32 @@ module MobyUtil
     # == raises
     def self.current_parser=( value )
 
+      #raise RuntimeError, "Parser can be set only once per session" unless defined?( @@parser )
+
+      # set current parser
       @@parser = value
 
-      nil
+      # 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 }") 
+
+          }
+        
+      end
+
+      # return current parser as result
+      value
 
     end
 
@@ -65,7 +84,7 @@ module MobyUtil
 
       begin
 
-        MobyUtil::XML::Document.new( nil, @@parser ).extend( @@parser::Document ).tap{ | document | 
+        MobyUtil::XML::Document.new( nil ).tap{ | document | 
 
           # parse given string
           document.xml = document.parse( xml_string ) 
@@ -80,37 +99,48 @@ module MobyUtil
           dump_location = ""
 
           # check if xml parse error logging is enabled
-          if MobyUtil::KernelHelper.to_boolean( MobyUtil::Parameter[ :logging_xml_parse_error_dump ] )
+          if $parameters[ :logging_xml_parse_error_dump, 'true' ].to_s.to_boolean
+
+            # construct filename for xml dump
+            filename = 'xml_error_dump'
+
+            # add timestamp to filename if not overwriting the existing dump file 
+            unless $parameters[ :logging_xml_parse_error_dump_overwrite, 'false' ].to_s.to_boolean
 
-            # generate filename for xml dump
-            filename = MobyUtil::KernelHelper.to_boolean( MobyUtil::Parameter[ :logging_xml_parse_error_dump_overwrite ] ) ? 'xml_error_dump.xml' : 'xml_error_dump_%i.xml' % Time.now
+              filename << "_#{ Time.now.to_i }"
+
+            end
+
+            # add file extension
+            filename << '.xml'
 
             # ... join filename with xml dump output path 
-            path = File.join( MobyUtil::FileHelper.expand_path( MobyUtil::Parameter[ :logging_xml_parse_error_dump_path ] ), filename )
+            path = File.join( MobyUtil::FileHelper.expand_path( $parameters[ :logging_xml_parse_error_dump_path ] ), filename )
 
             begin
 
               # write xml string to file
               File.open( path, "w" ){ | file | file << xml_string }
 
-              dump_location = ". Saved to %s" % path
+              dump_location = "Saved to #{ path }"
 
             rescue
 
-              dump_location = ". Error while saving to file %s" % path
+              dump_location = "Error while saving to file #{ path }"
 
             end
 
-
           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.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 }"
 
         else
         
           # raise exception
-          Kernel::raise MobyUtil::XML::ParseError.new( "%s (%s)" % [ exception.message.gsub("\n", ''), exception.class ] )
+          #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 })"
         
         end
 
@@ -132,7 +162,7 @@ module MobyUtil
     def self.parse_file( filename )    
 
       # raise exception if file not found
-      Kernel::raise IOError.new( "File '%s' not found" % filename ) unless File.exist?( filename )
+      Kernel::raise IOError, "File #{ filename.inspect } not found" unless File.exist?( filename )
 
       self.parse_string( IO.read( filename ) )
 
@@ -160,7 +190,7 @@ module MobyUtil
 
       begin
 
-        MobyUtil::XML::Builder.new.extend( @@parser::Builder ).tap{ | builder | 
+        MobyUtil::XML::Builder.new.tap{ | builder | 
 
           builder.build( &block )
 
@@ -168,16 +198,18 @@ module MobyUtil
 
       rescue Exception => exception
 
-        Kernel::raise MobyUtil::XML::BuilderError.new( "%s (%s)" % [ exception.message, exception.class ] )
-
+        Kernel::raise MobyUtil::XML::BuilderError, "#{ exception.message } (#{ exception.class })"
 
       end
       
     end
 
     # enable hooking for performance measurement & debug logging
-    MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
   end # XML
 
 end # MobyUtil
+
+# set used parser module
+MobyUtil::XML.current_parser = MobyUtil::XML::Nokogiri

data/lib/tdriver/verify/verify.rb

@@ -1,20 +1,20 @@
 ############################################################################
-## 
-## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 
-## All rights reserved. 
-## Contact: Nokia Corporation (testabilitydriver@nokia.com) 
-## 
-## This file is part of Testability Driver. 
-## 
-## If you have questions regarding the use of this file, please contact 
-## Nokia at testabilitydriver@nokia.com . 
-## 
-## This library is free software; you can redistribute it and/or 
-## modify it under the terms of the GNU Lesser General Public 
-## License version 2.1 as published by the Free Software Foundation 
-## and appearing in the file LICENSE.LGPL included in the packaging 
-## of this file. 
-## 
+##
+## Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+## All rights reserved.
+## Contact: Nokia Corporation (testabilitydriver@nokia.com)
+##
+## This file is part of Testability Driver.
+##
+## If you have questions regarding the use of this file, please contact
+## Nokia at testabilitydriver@nokia.com .
+##
+## This library is free software; you can redistribute it and/or
+## modify it under the terms of the GNU Lesser General Public
+## License version 2.1 as published by the Free Software Foundation
+## and appearing in the file LICENSE.LGPL included in the packaging
+## of this file.
+##
 ############################################################################
 
 module TDriverVerify
@@ -43,12 +43,12 @@ module TDriverVerify
 
       begin
 
-        @@on_error_verify_block.call 
+        @@on_error_verify_block.call
 
       rescue Exception => exception
 
-        raise exception.class.new( "Exception was raised while executing on_error_verify_block. Reason: %s" % [ exception.message ]) 
-          
+        raise exception.class.new( "Exception was raised while executing on_error_verify_block. Reason: %s" % [ exception.message ])
+
       end
 
     else
@@ -73,13 +73,14 @@ module TDriverVerify
 
   def verify( timeout = nil, message = nil, &block )
 
-    logging_enabled = MobyUtil::Logger.instance.enabled
+    logging_enabled = $logger.enabled
 
     verify_caller = caller(1).first.to_s
 
     begin
 
-      MobyUtil::Logger.instance.enabled = false
+      $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)
@@ -102,7 +103,7 @@ module TDriverVerify
           # no error => verification ok
           break
 
-        rescue Exception => e 
+        rescue Exception => e
 
           raise if e.kind_of? MobyBase::ContinuousVerificationError
 
@@ -119,8 +120,8 @@ module TDriverVerify
 
             rescue Exception
               # failed to load line from file, do nothing
-              MobyUtil::Logger.instance.enabled = logging_enabled
-              MobyUtil::Logger.instance.log "behaviour" , "WARNING;Failed to load source line: #{e.backtrace.inspect}.;#{self.kind_of?(MobyBase::SUT) ? self.id.to_s + ';sut' : ';'};{};verify;"
+              $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
 
             if !source_contents.empty?
@@ -147,8 +148,8 @@ module TDriverVerify
 
       raise if e.kind_of? MobyBase::ContinuousVerificationError
 
-      MobyUtil::Logger.instance.enabled = logging_enabled
-      MobyUtil::Logger.instance.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;"
+      $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
 
     ensure
@@ -157,8 +158,8 @@ module TDriverVerify
 
     end
 
-    MobyUtil::Logger.instance.enabled = logging_enabled
-    MobyUtil::Logger.instance.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.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;"
 
     return nil
 
@@ -178,11 +179,11 @@ module TDriverVerify
   # VerificationError:: The verification failed.
   def verify_not( timeout = nil, message = nil, &block )
 
-    logging_enabled = MobyUtil::Logger.instance.enabled
+    logging_enabled = $logger.enabled
     verify_caller = caller(1).first.to_s
     begin
 
-      MobyUtil::Logger.instance.enabled = false
+      $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)
@@ -242,8 +243,8 @@ module TDriverVerify
 
       raise if e.kind_of? MobyBase::ContinuousVerificationError
 
-      MobyUtil::Logger.instance.enabled = logging_enabled
-      MobyUtil::Logger.instance.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.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;"
       Kernel::raise e
 
     ensure
@@ -252,8 +253,8 @@ module TDriverVerify
 
     end
 
-    MobyUtil::Logger.instance.enabled = logging_enabled
-    MobyUtil::Logger.instance.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.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;"
     return nil
 
   end
@@ -272,11 +273,11 @@ module TDriverVerify
   # RuntimeError:: An unexpected error was encountered during verification.
   def verify_true( timeout = nil, message = nil, &block )
 
-    logging_enabled = MobyUtil::Logger.instance.enabled
+    logging_enabled = $logger.enabled
     verify_caller = caller(1).first.to_s
 
     begin
-      MobyUtil::Logger.instance.enabled = false
+      $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)
@@ -299,7 +300,7 @@ module TDriverVerify
 
             result = yield
 
-          rescue Exception => e 
+          rescue Exception => e
 
             #@@on_error_verify_block.call unless @@on_error_verify_block.nil?
 
@@ -316,12 +317,12 @@ module TDriverVerify
 
           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 = "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          
+            error_msg << "\nThe block did not return true. It returned: " << result.inspect
 
-              raise MobyBase::VerificationError.new( error_msg ) 
+            raise MobyBase::VerificationError.new( error_msg )
 
           end
 
@@ -348,7 +349,7 @@ module TDriverVerify
 
           raise if e.kind_of? MobyBase::ContinuousVerificationError
 
-          MobyUtil::Logger.instance.enabled = logging_enabled
+          $logger.enabled = logging_enabled
 
           # an unexpected error has occurred
           Kernel::raise RuntimeError.new("An unexpected error was encountered during verification:\n" << e.inspect )
@@ -359,15 +360,15 @@ module TDriverVerify
 
     rescue Exception => e
       raise if e.kind_of? MobyBase::ContinuousVerificationError
-      MobyUtil::Logger.instance.enabled = logging_enabled
-      MobyUtil::Logger.instance.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.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;"
       Kernel::raise e
     ensure
       MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout unless original_sync_timeout.nil?
     end
 
-    MobyUtil::Logger.instance.enabled = logging_enabled
-    MobyUtil::Logger.instance.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.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;"
     return nil
 
   end
@@ -386,13 +387,13 @@ module TDriverVerify
   # RuntimeError:: An unexpected error was encountered during verification.
   def verify_false( timeout = nil, message = nil, &block )
 
-    logging_enabled = MobyUtil::Logger.instance.enabled
+    logging_enabled = $logger.enabled
 
     verify_caller = caller(1).first.to_s
 
     begin
 
-      MobyUtil::Logger.instance.enabled = false
+      $logger.enabled = false
 
       Kernel::raise ArgumentError.new("No block was given.") unless block_given?
 
@@ -423,7 +424,7 @@ module TDriverVerify
 
           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          
+          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
@@ -445,7 +446,7 @@ module TDriverVerify
         rescue Exception => e
           raise if e.kind_of? MobyBase::ContinuousVerificationError
           # an unexpected error has occurred
-          MobyUtil::Logger.instance.enabled = logging_enabled
+          $logger.enabled = logging_enabled
           Kernel::raise RuntimeError.new("An unexpected error was encountered during verification:\n" << e.inspect )
 
         end # begin, catch any VerificationErrors
@@ -458,8 +459,8 @@ module TDriverVerify
 
       raise if e.kind_of? MobyBase::ContinuousVerificationError
 
-      MobyUtil::Logger.instance.enabled = logging_enabled
-      MobyUtil::Logger.instance.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.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;"
 
       Kernel::raise e
 
@@ -467,8 +468,8 @@ module TDriverVerify
       MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout unless original_sync_timeout.nil?
     end
 
-    MobyUtil::Logger.instance.enabled = logging_enabled
-    MobyUtil::Logger.instance.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.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;"
     return nil
 
   end
@@ -487,10 +488,10 @@ module TDriverVerify
   # VerificationError:: The verification failed.
   # RuntimeError:: An unexpected error was encountered during verification.
   def verify_equal( expected, timeout = nil, message = nil, &block )
-    logging_enabled = MobyUtil::Logger.instance.enabled
+    logging_enabled = $logger.enabled
     verify_caller = caller(1).first.to_s
     begin
-      MobyUtil::Logger.instance.enabled = false
+      $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)
@@ -521,7 +522,7 @@ module TDriverVerify
           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            
+            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
@@ -555,19 +556,159 @@ module TDriverVerify
 
       raise if e.kind_of? MobyBase::ContinuousVerificationError
 
-      MobyUtil::Logger.instance.enabled = logging_enabled
-      MobyUtil::Logger.instance.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.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
       Kernel::raise e
     ensure
       MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout unless original_sync_timeout.nil?
     end
 
-    MobyUtil::Logger.instance.enabled = logging_enabled
-    MobyUtil::Logger.instance.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.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
     return 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, timeout = nil, message = nil, &block )
+
+    logging_enabled = $logger.enabled
+
+    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
+
+      #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 )
+
+      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
+
+          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
+
+          # break loop if no exceptions thrown
+          break
+
+        rescue MobyBase::VerificationError
+
+          # refresh and retry unless timeout reached
+
+          raise $! if Time.new > timeout_time
+
+          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 )
+
+          # 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 )
+
+      $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 }" 
+
+      raise $!
+
+    ensure
+    
+      MobyBase::TestObjectFactory.instance.timeout = original_sync_timeout
+
+      $logger.enabled = logging_enabled
+      
+    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
+
+  end
+
+
   # Verifies that the given signal is emitted.
   #
   # === params
@@ -582,12 +723,12 @@ module TDriverVerify
   # VerificationError:: The verification failed.
   def verify_signal( timeout, signal_name, message = nil, &block )
 
-    logging_enabled = MobyUtil::Logger.instance.enabled
+    logging_enabled = $logger.enabled
     verify_caller = caller(1).first.to_s
 
     begin
 
-      MobyUtil::Logger.instance.enabled = false
+      $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?))
@@ -601,7 +742,7 @@ module TDriverVerify
 
         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 << "The signal #{signal_name} was not emitted in #{timeout} seconds."
         error_msg << "\nNested exception:\n" << e.inspect
         Kernel::raise MobyBase::VerificationError.new(error_msg)
 
@@ -611,13 +752,13 @@ module TDriverVerify
 
       execute_on_error_verify_block unless @@on_error_verify_block.nil?
 
-      MobyUtil::Logger.instance.enabled = logging_enabled
-      MobyUtil::Logger.instance.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}"
+      $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
 
-    MobyUtil::Logger.instance.enabled = logging_enabled
-    MobyUtil::Logger.instance.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}"
+    $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
@@ -647,12 +788,14 @@ module TDriverVerify
     counter
   end
 
-  # Refresh ui state inside verify
-  def refresh_suts
-    begin
-      if self.kind_of? MobyBase::SUT
-        appid = self.get_application_id
-        if appid != "-1"
+  def verify_refresh(b_use_id=true)
+    if self.kind_of? MobyBase::SUT
+        begin
+          appid = self.get_application_id
+        rescue
+          appid='-1'
+        end
+        if appid != "-1" && b_use_id
           self.refresh({:id => appid})
         else
           self.refresh
@@ -660,21 +803,35 @@ module TDriverVerify
       else
         #refresh all connected suts
         MobyBase::SUTFactory.instance.connected_suts.each do |sut_id, sut_attributes|
-          appid = sut_attributes[:sut].get_application_id
-          if appid != "-1"
+          begin
+            appid = sut_attributes[:sut].get_application_id
+          rescue
+            appid='-1'
+          end
+          if appid != "-1" && b_use_id
             sut_attributes[:sut].refresh({:id => appid}) if sut_attributes[:is_connected]
           else
             sut_attributes[:sut].refresh if sut_attributes[:is_connected]
           end
         end
       end
+  end
 
+  # Refresh ui state inside verify
+  def refresh_suts
+    begin
+      verify_refresh
       # Ignore all availability errors
-    rescue RuntimeError => e
-      # This occurs when no applications are registered to sut
-      if !(e.message =~ /no longer available/)
-        # all other errors are passed up
-        raise e
+    rescue RuntimeError, MobyBase::ApplicationNotAvailableError => e
+      begin
+        verify_refresh(false)
+      rescue RuntimeError, MobyBase::ApplicationNotAvailableError => e
+        # This occurs when no applications are registered to sut
+        if !(e.message =~ /no longer available/)
+          puts 'Raising exception'
+          # all other errors are passed up
+          raise e
+        end
       end
     end
   end