testability-driver 0.9.2 → 1.0.0

data/lib/tdriver/base/behaviour/behaviours/object_behaviour_composition.rb

@@ -43,7 +43,7 @@ module MobyBehaviour
 	module ObjectBehaviourComposition
 
   public
-
+    # == nodoc
     # == description
     # Apply all behaviour modules to target object which meets the given rules. Target object can be either type of "sut", "application" or "*" (any test object). 
     # == tables

data/lib/tdriver/base/behaviour/behaviours/object_behaviour_description.rb

@@ -125,17 +125,23 @@ module MobyBehaviour
     #  description: When 'return_result' is false
     #  example: nil
     #
-    # == footer
+    # == exceptions
+    # TypeError
+    #  description: Wrong argument type %s for method name (expected Symbol or String)
+    #
+    # ArgumentError
+    #  description: Test object type of %s does not have method %s
     #
 		def describe_method( method_name, print = true, return_result = false )
 			
+      # verify that method_name is type of Symbol or String 
+      method_name.check_type( [ Symbol, String ], "Wrong argument type $1 for method name (expected $2)" )
+
 			# convert to symbol if method_name is a string
 			method_name = method_name.to_sym if method_name.kind_of?( String )
 
-			Kernel::raise ArgumentError.new("Wrong argument type for method name. (Actual: #{ method_name.class }, Expected: Symbol)") unless method_name.kind_of?( Symbol )
-
 			# print result to stdout if argument not boolean
-			print = true unless [ TrueClass, FalseClass ].include? print.class
+			print = true unless [ TrueClass, FalseClass ].include?( print.class )
 
 			# return result not printed out to stdout 
 			return_result = true unless print
@@ -154,7 +160,7 @@ module MobyBehaviour
 				
 			}
 
-			Kernel::raise RuntimeError.new("No such method for object type of #{ self.type }") if result_hash.nil?
+			Kernel::raise ArgumentError.new( "Test object type of %s does not have method %s" % [ self.type, method_name ] ) if result_hash.nil?
 
 			if print
 
@@ -209,8 +215,6 @@ module MobyBehaviour
     # NilClass
     #  description: When 'return_result' is false
     #  example: nil
-    #
-    # == footer
     #
 		def describe( print = true, return_result = false )
 

data/lib/tdriver/base/behaviour/behaviours/object_composition.rb

@@ -61,6 +61,8 @@ module MobyBehaviour
 		# === raises
 		def add_parent( parent_object )
 
+      warn("Warning: Deprecated method, use store to @parent instead of using this method") 
+
 			@parent = parent_object
 
 		end
@@ -73,6 +75,8 @@ module MobyBehaviour
 		# ?
 		def remove_parent()
 
+      warn("Warning: Deprecated method, set @parent to nil instead of using this method") 
+
 			@parent = nil
 
 		end
@@ -86,6 +90,8 @@ module MobyBehaviour
 		# === raises
 		def add_child( new_child_object ) 
 
+      warn("Warning: Deprecated method, use @child_object_cache.add_object instead of this method")
+
 			@_child_object_cache.merge!( new_child_object.hash => new_child_object )
 
 		end
@@ -99,6 +105,8 @@ module MobyBehaviour
 		# === raises
 		def remove_child( target_child_object )
 
+      warn("Warning: Deprecated method, use @child_object_cache.add_object instead of this method")
+
 			@_child_object_cache.delete( target_child_object.hash )
 
 		end

data/lib/tdriver/base/behaviour/factory.rb

@@ -19,302 +19,321 @@
 
 module MobyBase
 
-	# TODO: document BehaviourFactory class
-	class BehaviourFactory
+  # TODO: document BehaviourFactory class
+  class BehaviourFactory
 
-		include Singleton
+	include Singleton
 	
-		def initialize
+	def initialize
 
-			@@behaviours = []
-			@@behaviours_cache = {}
-			@@modules_cache = {}
-	
-			# behaviour xml files path
-			@@path = File.join( MobyUtil::FileHelper.tdriver_home, '/behaviours/*.xml' )
+	  @@behaviours = []
+	  @@behaviours_cache = {}
+	  @@modules_cache = {}
+	  
+	  # behaviour xml files path
+	  @@path = File.join( MobyUtil::FileHelper.tdriver_home, '/behaviours/*.xml' )
 
-			parse_behaviour_files( 
+	  parse_behaviour_files( 
 
-				load_behaviours( @@path ) 
+							load_behaviours( @@path ) 
 
-			)
+							)
 
-		end
+	end
 
 	public
 
-		def to_xml( rules = {} ) 
+	def to_xml( rules = {} ) 
 
-			@_method_index = nil
+	  @_method_index = nil
 
-			rules.default = [ '*' ]
+	  rules.default = [ '*' ]
 
-			rules.each_pair{ | key, value |
+	  rules.each_pair{ | key, value |
 
-				rules[ key ] = [ value ] if value.kind_of?( String )
+		rules[ key ] = [ value ] if value.kind_of?( String )
 
-			}
+	  }
 
-			MobyUtil::XML.build{
+	  MobyUtil::XML.build{
 
-				behaviours{
+		behaviours{
 
-					@@behaviours.each_index{ | index |
+		  @@behaviours.each_index{ | index |
 
-						@_method_index = index
+			@_method_index = index
 
-						behaviour = @@behaviours[ @_method_index ]
+			behaviour = @@behaviours[ @_method_index ]
 
-						if ( ( rules[ :name ] == behaviour[ :name ] ) ||  
+			if ( ( rules[ :name ] == behaviour[ :name ] ) ||  
 
-								( rules[ :name ] == [ '*' ] ) &&
+				( rules[ :name ] == [ '*' ] ) &&
 
-								( !( rules[ :sut_type ] & behaviour[ :sut_type ] ).empty? ) && 
-								( !( rules[ :input_type ] & behaviour[ :input_type ] ).empty? ) && 
-								( !( rules[ :object_type ] & behaviour[ :object_type ] ).empty? ) && 
-								( !( rules[ :version ] & behaviour[ :version ] ).empty? )
+#				( !( rules[ :sut_type ] & behaviour[ :sut_type ] ).empty? ) && 
+				( !( rules[ :input_type ] & behaviour[ :input_type ] ).empty? ) && 
+				( !( rules[ :object_type ] & behaviour[ :object_type ] ).empty? ) && 
+				( !( rules[ :version ] & behaviour[ :version ] ).empty? )
 
-							) 
+				) 
 
-								behaviour( :name => @@behaviours[ @_method_index ][ :name ], :object_type => @@behaviours[ @_method_index ][ :object_type ].join(";") ){ 
-									object_methods{
-										@@behaviours[ @_method_index ][ :methods ].each { | key, value |
-											object_method( :name => key.to_s ) {	
-												description( value[:description] )
-												example( value[:example] )
-											}
-										}
-									}
-								}
+			  behaviour( :name => @@behaviours[ @_method_index ][ :name ], :object_type => @@behaviours[ @_method_index ][ :object_type ].join(";") ){ 
+				object_methods{
+				  @@behaviours[ @_method_index ][ :methods ].each { | key, value |
+					object_method( :name => key.to_s ) {	
+					  description( value[:description] )
+					  example( value[:example] )
+					}
+				  }
+				}
+			  }
 
-						end
+			end
 
-					}
+		  }
 
-				}
+		}
 
-			}.to_xml
+	  }.to_xml
 
-		end
+	end
 
-		def get_behaviour_at_index( index )
+	def get_behaviour_at_index( index )
 
-			result = @@behaviours[ index ]
+	  result = @@behaviours[ index ]
 
-			if result.nil? 
+	  if result.nil? 
 
-				Kernel::raise RuntimeError.new( "No behaviour at index #{ index }" )
+		Kernel::raise RuntimeError.new( "No behaviour at index #{ index }" )
 
-			else
+	  else
 
-				result
+		result
 
-			end
+	  end
 
-		end
+	end
 
-		def apply_behaviour!( rules = {} )
+	def apply_behaviour!( rules = {} )
 
-			# merge user-defined rules on top of default rules set
-			#rules = { :sut_type => ['*'], :object_type => ['*'], :input_type => ['*'], :version => ['*'] }.merge!( rules )
+	  # merge user-defined rules on top of default rules set
+	  #rules = { :sut_type => ['*'], :object_type => ['*'], :input_type => ['*'], :version => ['*'] }.merge!( rules )
 
-      rules.default = ['*']
+    rules.default = ['*']
 
-			Kernel::raise ArgumentError.new( "No target object defined in rules hash" ) if rules[ :object ].nil?			
+	  Kernel::raise ArgumentError.new( "Target object not defined in rules hash" ) if rules[ :object ].nil?			
 
-			# apply behaviours to target object
-			( get_object_behaviours( rules ) ).each{ | behaviour_index |
+	  # apply behaviours to target object
+	  ( get_object_behaviours( rules ) ).each{ | behaviour_index |
 
-				behaviour_data = @@behaviours[ behaviour_index ]
+		behaviour_data = @@behaviours[ behaviour_index ]
 
-				# skip if required plugin is not registered or enabled
-				next if behaviour_data[ :requires ].collect{ | plugin | 
+		# skip if required plugin is not registered or enabled
+		next if behaviour_data[ :requires ].collect{ | plugin | 
 
-					#MobyUtil::PluginService.instance.plugin_registered?( plugin ) && MobyUtil::PluginService.instance.plugin_enabled?( plugin )
+		  #MobyUtil::PluginService.instance.plugin_registered?( plugin ) && MobyUtil::PluginService.instance.plugin_enabled?( plugin )
 
           # verify if plugin is enabled -- exception will be catched if plugin is not registered 
-					MobyUtil::PluginService.instance.plugin_enabled?( plugin ) rescue false
+		  MobyUtil::PluginService.instance.plugin_enabled?( plugin ) rescue false
 
-				}.include?( false )
+		}.include?( false )
 
-				begin
+		begin
 
-					#behaviour_module = MobyUtil::KernelHelper.get_constant( behaviour_data[ :module ][ :name ] )
+		  #behaviour_module = MobyUtil::KernelHelper.get_constant( behaviour_data[ :module ][ :name ] )
 
-					# retrieve behaviour module from cache and extend target object
-					rules[ :object ].extend( 
+		  # retrieve behaviour module from cache and extend target object
+		  rules[ :object ].extend( 
+								  @@modules_cache.fetch( behaviour_data[ :module ][ :name ] ){ | name |									
+									# ... or store to cache for the next time if not found 
+									@@modules_cache[ name ] = MobyUtil::KernelHelper.get_constant( name )
+								  } 
+								  )
 
-            @@modules_cache.fetch( behaviour_data[ :module ][ :name ] ){ | name |
-            
-              # ... or store to cache for the next time if not found 
-              @@modules_cache[ name ] = MobyUtil::KernelHelper.get_constant( name )
+		rescue NameError => exception
 
-            } 
+		  Kernel::raise exception.class.new( 
+											"Implementation for behaviour %s does not exist. (%s)" % [ behaviour_data[ :name ], behaviour_data[ :module ][ :name ] ]
+											)
 
-          )
+		rescue Exception => exception
 
-				rescue NameError => exception
+		  Kernel::raise RuntimeError.new( 
+										 "Error while applying %s (%s) behaviour to target object. Reason: %s (%s)" % [
+										   behaviour_data[ :name ],
+										   behaviour_data[ :module ][ :name ],	
+										   exception.message,
+										   exception.class
+										 ]
+										 )
 
-					Kernel::raise exception.class.new( 
-						"Implementation for behaviour %s does not exist. (%s)" % [ behaviour_data[ :name ], behaviour_data[ :module ][ :name ] ]
-					)
+		end
 
-				rescue Exception => exception
+		# add behaviour information to test object
+		rules[ :object ].instance_exec{ 
 
-					Kernel::raise RuntimeError.new( 
-						"Error while applying %s (%s) behaviour to target object. Reason: %s (%s)" % [
-							behaviour_data[ :name ],
-							behaviour_data[ :module ][ :name ],	
-							exception.message,
-							exception.class
-						]
-					)
+		  @object_behaviours.push( behaviour_index ) unless @object_behaviours.include? behaviour_index 
 
-				end
+		}
 
-				# add behaviour information to test object
-				rules[ :object ].instance_exec{ 
+	  }
 
-					@object_behaviours.push( behaviour_index ) unless @object_behaviours.include? behaviour_index 
+	end
 
-				}
+	private
 
-			}
+	def load_behaviours( behaviour_files )
 
-		end
+	  behaviours_data = []
 
-	private
+	  @file_name = ""
 
-		def load_behaviours( behaviour_files )
+	  begin
 
-			behaviours_data = []
+		Dir.glob( behaviour_files ).each { | behaviour | 
 
-			@file_name = ""
+		  @file_name = behaviour
 
-			begin
+		  behaviours_data << { :filename => @file_name, :xml => MobyUtil::FileHelper.get_file( @file_name ) }
 
-				Dir.glob( behaviour_files ).each { | behaviour | 
+		}
 
-					@file_name = behaviour
+	  rescue MobyUtil::EmptyFilenameError
 
-					behaviours_data << { :filename => @file_name, :xml => MobyUtil::FileHelper.get_file( @file_name ) }
+		Kernel::raise EmptyFilenameError.new( "Unable to load behaviours xml file due to filename is empty or nil" )
 
-				}
+	  rescue MobyUtil::FileNotFoundError => ex
 
-			rescue MobyUtil::EmptyFilenameError
+		Kernel::raise ex
 
-				Kernel::raise EmptyFilenameError.new( "Unable to load behaviours xml file due to filename is empty or nil" )
+	  rescue IOError => ex
 
-			rescue MobyUtil::FileNotFoundError => ex
+		Kernel::raise IOError.new("Error occured while loading behaviours xml file %s. Reason: %s" % [ @file_name, ex.message ] )
 
-				Kernel::raise ex
+	  rescue => ex
 
-			rescue IOError => ex
+		Kernel::raise RuntimeError.new( "Error occured while parsing behaviours xml file %s. Reason: %s (%s)" % [ @file_name, ex.message, ex.class ] )
 
-				Kernel::raise IOError.new("Error occured while loading behaviours xml file %s. Reason: %s" % [ @file_name, ex.message ] )
+	  end
 
-			rescue => ex
+	  behaviours_data
 
-				Kernel::raise RuntimeError.new( "Error occured while parsing behaviours xml file %s. Reason: %s (%s)" % [ @file_name, ex.message, ex.class ] )
+	end
 
-			end
+	def parse_behaviour_files( behaviour_files )
 
-			behaviours_data
+	  behaviour_files.each{ | behaviours | 
 
-		end
+		begin
 
-		def parse_behaviour_files( behaviour_files )
+      # skip parsing the xml if string is empty
+      next if behaviours[ :xml ].empty?
 
-			behaviour_files.each{ | behaviours | 
+		  # parse behaviour xml
+		  document = MobyUtil::XML.parse_string( behaviours[ :xml ] )
 
-				begin
+		rescue => exception
 
-					# parse behaviour xml
-					document = MobyUtil::XML.parse_string( behaviours[ :xml ] )
+		  Kernel::raise MobyUtil::XML::ParseError.new( 
+													  "Error occured while parsing behaviour XML file %s. Error: %s " % [ behaviours[ :filename ], exception.message ] 
+													  ) 
 
-				rescue => exception
+		end
 
-					Kernel::raise MobyUtil::XML::ParseError.new( 
-					  "Error occured while parsing behaviour XML file %s. Error: %s " % [ behaviours[ :filename ], exception.message ] 
-				  ) 
+		# retrieve root attributes
+		root_attributes = document.root.xpath( "/behaviours" ).first.attributes
 
-				end
+		# parse retrieve behaviour definitions
+		document.root.xpath( "/behaviours/behaviour" ).each{ | node |
 
-				# retrieve root attributes
-				root_attributes = document.root.xpath( "/behaviours" ).first.attributes
+		  # retrieve behaviour attributes & module node
+		  attributes = node.attributes
 
-				# parse retrieve behaviour definitions
-				document.root.xpath( "/behaviours/behaviour" ).each{ | node |
+		  name = attributes[ "name" ].to_s
+		  object_type = attributes[ "object_type" ].to_s
+		  input_type = attributes[ "input_type" ].to_s
+		  sut_type = attributes[ "sut_type" ].to_s
+		  version = attributes[ "version" ].to_s
 
-					# retrieve behaviour attributes & module node
-					attributes = node.attributes
+		  env = ( attributes[ "env" ] || '*' ).to_s 
 
-					name = attributes[ "name" ].to_s
-					object_type = attributes[ "object_type" ].to_s
-					input_type = attributes[ "input_type" ].to_s
-					sut_type = attributes[ "sut_type" ].to_s
-					version = attributes[ "version" ].to_s
+		  module_node = node.xpath( 'module' ).first
+		  
+		  name = attributes[ "name" ].to_s
+		  object_type = attributes[ "object_type" ].to_s
+		  input_type = attributes[ "input_type" ].to_s
+		  sut_type = attributes[ "sut_type" ].to_s
+		  version = attributes[ "version" ].to_s
+		  
+		  # verify that all required attributes and nodes are found in behaviour xml node
+		  #Kernel::raise RuntimeError.new("Behaviour does not have a name, please see behaviour XML files") if name.empty?
+		  name.not_empty("Behaviour element does not have name (name) attribute defined, please see behaviour XML files", RuntimeError)
+		  
+		  #Kernel::raise RuntimeError.new("Behaviour target object type not defined for #{ name } in XML") if object_type.empty?
+		  object_type.not_empty("Behaviour element does not have target object type (object_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
 
-					# verify that all required attributes and nodes are found in behaviour xml node
-					Kernel::raise RuntimeError.new("Behaviour does not have a name, please see behaviour XML files") if name.empty?
-					Kernel::raise RuntimeError.new("Behaviour target object type not defined for #{ name } in XML") if object_type.empty?
-					Kernel::raise RuntimeError.new("Behaviour target object input type not defined for #{ name } in XML") if input_type.empty?
-					Kernel::raise RuntimeError.new("Behaviour target object sut type not defined for #{ name } in XML") if sut_type.empty?
-					Kernel::raise RuntimeError.new("Behaviour target object sut version not defined for #{ name } in XML") if version.empty?
+		  #Kernel::raise RuntimeError.new("Behaviour target object input type not defined for #{ name } in XML") if input_type.empty?
+		  input_type.not_empty("Behaviour element does not have target object input type (input_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
 
-					module_node = node.xpath( 'module' ).first
+		  #Kernel::raise RuntimeError.new("Behaviour target object sut type not defined for #{ name } in XML") if sut_type.empty?
+		  sut_type.not_empty("Behaviour element does not have target object sut type (sut_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
 
-					Kernel::raise RuntimeError.new("Behaviour implementation module not defined for #{ name } in XML") if module_node.nil?
+		  #Kernel::raise RuntimeError.new("Behaviour target object sut version not defined for #{ name } in XML") if version.empty?
+		  version.not_empty("Behaviour element does not have target object SUT version (version) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
 
-					# retrieve module name & implementation filename
-					module_attributes = module_node.attributes
-				
-					module_file = module_attributes[ "file" ].to_s # optional
-					module_name = module_attributes[ "name" ].to_s 
+		  #Kernel::raise RuntimeError.new("Behaviour implementation module not defined for #{ name } in XML") if module_node.nil?
+		  module_node.not_nil("Behaviour does not have implementation module element defined, please see #{ name } in behaviour XML files", RuntimeError)
+		  
+		  # retrieve module name & implementation filename
+		  module_attributes = module_node.attributes
+		  module_file = module_attributes[ "file" ].to_s # optional
+		  module_name = module_attributes[ "name" ].to_s 
+		  
+		  #Kernel::raise RuntimeError.new( "Behaviour implementation module name not defined for #{ name } in XML") if module_name.empty?
+          module_name.not_empty("Behaviour does not have implementation module name defined, please see #{ name } in behaviour XML files", RuntimeError)
 
-					Kernel::raise RuntimeError.new( "Behaviour implementation module name not defined for #{ name } in XML") if module_name.empty?
+		  methods_hash = {}
 
-					methods_hash = {}
+		  # create hash of methods
+		  node.xpath( 'methods/method' ).each{ | method |
 
-					# create hash of methods
-					node.xpath( 'methods/method' ).each{ | method |
+			  # retrieve method description & example and store to methods hash
+			  methods_hash[ method.attribute( "name" ).to_s.to_sym ] = {
 
-						# retrieve method description & example and store to methods hash
-						methods_hash[ method.attribute( "name" ).to_s.to_sym ] = {
+			    :description => method.at_xpath( 'description/text()' ).to_s, 
 
-							:description => ( method.xpath( 'description' ).first.content rescue "" ), 
-							:example => ( method.xpath( 'example' ).first.content rescue "" )
+			    :example     => method.at_xpath( 'example/text()' ).to_s
 
-						}
+  			}
 
-					}
+		  }
 
-					# create and store beahaviour hash
-					@@behaviours << {
+		  # create and store beahaviour hash
+		  @@behaviours << {
 
-						:name => name,
-						:requires => root_attributes[ "plugin" ].to_s.split(";"),
-						:object_type => object_type.split(";"),
-						:input_type => input_type.split(";"),
-						:sut_type => sut_type.split(";"),
-						:version => version.split(";"),
-			
-						:module => { 
-							:file => module_file, 
-							:name => module_name 
-						},
+			:name => name,
+			:requires => root_attributes[ "plugin" ].to_s.split(";"),
+			:object_type => object_type.split(";"),
+			:input_type => input_type.split(";"),
+#			:sut_type => sut_type.split(";"),
+			:version => version.split(";"),
+			:env => env.split(";"),
 
-						:methods => methods_hash
+			:module => { 
+			  :file => module_file, 
+			  :name => module_name 
+			},
 
-					}
+			:methods => methods_hash
 
-				}
+		  }
 
-			}
+		}
 
-		end
+	  }
 
-		def get_object_behaviours( rules )
+	end
+
+	def get_object_behaviours( rules )
 
       # calculate hash for behaviour rules / hash value will be used to identify similar objects
       behaviour_hash = Hash[ rules.select{ | key, value | key != :object  } ].hash
@@ -326,55 +345,56 @@ module MobyBase
 
       else
 
-			  rules.default = [ '*' ]
+		rules.default = [ '*' ]
 
-			  extended_modules = []
+		extended_modules = []
 
-			  @@behaviours.each_with_index{ | behaviour, index |
+		@@behaviours.each_with_index{ | behaviour, index |
 
-				  if ( 	( rules[ :name ] == behaviour[ :name ] ) || 
+		  if ( 	( rules[ :name ] == behaviour[ :name ] ) || 
 
-					  ( rules[ :name ] == [ '*' ] && 
+			  ( rules[ :name ] == [ '*' ] && 
 
-						  ( !( rules[ :sut_type ] & behaviour[ :sut_type ] ).empty? ) && 
-						  ( !( rules[ :object_type ] & behaviour[ :object_type ] ).empty? ) &&
-						  ( !( rules[ :input_type ] & behaviour[ :input_type ] ).empty? ) &&
-						  ( !( rules[ :version ] & behaviour[ :version ] ).empty? ) ) )
+#			   ( !( rules[ :sut_type ] & behaviour[ :sut_type ] ).empty? ) && 
+			   ( !( rules[ :object_type ] & behaviour[ :object_type ] ).empty? ) &&
+			   ( !( rules[ :input_type ] & behaviour[ :input_type ] ).empty? ) &&
+			   ( !( rules[ :env ] & behaviour[ :env ] ).empty? ) &&
+			   ( !( rules[ :version ] & behaviour[ :version ] ).empty? ) ) )
 
-						  # retrieve list of extended modules
-						  extended_modules << index
+			# retrieve list of extended modules
+			extended_modules << index
 
-				  end
+		  end
 
-			  }
+		}
 
         # store behaviour module indexes to cache
         @@behaviours_cache[ behaviour_hash ] = extended_modules
 
       end
 
-		end
+	end
 
-		def get_behaviour_from_cache( target, sut_type, object_type, sut_version, input_type )
+	def get_behaviour_from_cache( target, sut_type, object_type, sut_version, input_type )
 
-			if @_behaviour_cache.has_key?( object_type )
+	  if @_behaviour_cache.has_key?( object_type )
 
-				# apply modules to target object
-				@_behaviour_cache[ object_type ].each{ | module_name | target.instance_eval( "self.extend(#{ module_name })" ) }
+		# apply modules to target object
+		@_behaviour_cache[ object_type ].each{ | module_name | target.instance_eval( "self.extend(#{ module_name })" ) }
 
-				# return true
-				true
+		# return true
+		true
 
-			else
-				# return false
-				false
-			end
+	  else
+		# return false
+		false
+	  end
 
-		end
+	end
 
-		# enable hooking for performance measurement & debug logging
-		MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+	# enable hooking for performance measurement & debug logging
+	MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
 
-	end # BehaviourGenerator
+  end # BehaviourGenerator
 
 end # MobyBase