docgenerator 1.2.1 → 2.0.0

data/unittest/unittest_creole_placeholders.rb

@@ -0,0 +1,272 @@
+if $0 == __FILE__
+  $:.unshift("../lib")
+end
+
+gem 'test-unit'
+require 'test/unit'
+require 'more_unit_test/assert_equal_filecontent.rb'
+
+require 'creole/creole2doc.rb'
+require 'creole/plugins/rail.rb'
+require 'creole/plugins/struktex.rb'
+require 'creole/plugins/todonotes.rb'
+require 'creole/plugins/rubycode4creole.rb'
+
+#~ DOCGENERATOR_LOGGER.level = Log4r::DEBUG
+#~ DOCGENERATOR_DEFAULT_LOGGER.level = Log4r::WARN
+#~ Docgenerator.trace_on
+
+
+#Avoid warnings about missing logger in to_doc
+OPT = { :log => Docgenerator::DOCGENERATOR_DEFAULT_LOGGER }  unless defined? OPT
+
+require 'log4r'
+#Warn -> report missing important test
+#Info -> report missing test
+$log = Log4r::Logger.new('Unittest creole', Log4r::ERROR)
+#~ $log = Log4r::Logger.new('Unittest creole', Log4r::WARN)
+#~ $log = Log4r::Logger.new('Unittest creole', Log4r::INFO)
+$log.outputters = Log4r::StdoutOutputter.new('log_stdout')
+
+#Logger to catch unwanted messages
+$tmplog = Log4r::Logger.new('Creole', Log4r::FATAL)
+
+<<missingtests
+erweitern:
+*tabulars 
+*Creole_creoletab
+*csv-tabs
+
+placeholder mit parameter (siehe creole_rail)
+
+Bug:
+http://... am Ende ohne folgenden Text wird falsch erkannt.
+--> test_creole_links_implicit_end()
+missingtests
+
+class Test_creole_placeholder_interface < Test::Unit::TestCase
+  def test_creole_placeholders()
+    creole = Docgenerator::Creole::Creole.new(:content => <<creole
+==Titel 1==
+Text
+creole
+    )
+    assert_equal( Docgenerator::Creole::Placeholders::Collection, creole.placeholders)
+    assert_equal( Docgenerator::Creole::Placeholders::Dummy, Docgenerator::Creole::Placeholders::Collection[:undefined])
+    assert_equal( Docgenerator::Creole::Placeholders::Creole_html, Docgenerator::Creole::Placeholders::Collection['html'])
+    #~ assert_instance_of( Dummy_placeholder, Creole::Placeholders[:undefined])
+  end #test_creole_placeholders
+
+=begin 
+Define test for each placeholder.
+=end
+  Docgenerator::Creole::Placeholders::Collection.each{|key,placeholder_class|
+    code = <<-xx
+      def test_#{placeholder_class.to_s.gsub(/::/, '_')}()
+        do_interfacetest('#{key}', #{placeholder_class})
+      end
+      xx
+    class_eval(code)
+  }
+=begin rdoc
+Test, if the interface for a placeholder follows the main definition.
+
+=end
+  def do_interfacetest(key,placeholder_class)
+      assert_equal( placeholder_class, Docgenerator::Creole::Placeholders[key])
+      assert_equal( placeholder_class, Docgenerator::Creole::Placeholders::Collection[key])
+      assert_equal( placeholder_class, Docgenerator::Creole::Creole.new.placeholders[key])
+      
+      assert_nothing_raised("Interface error for class #{placeholder_class}"){ 
+        begin
+          placeholder = placeholder_class.new( Docgenerator::Creole::Creole.new ) 
+        rescue Docgenerator::Creole::Placeholder::ParameterError
+          #Docgenerator::Creole_placeholder::ParameterError is an accepted error
+          #Happens if this placeholder needs a parameter.
+        else
+        #Check inheritance.
+        assert_kind_of( Docgenerator::Creole::Placeholder, placeholder)
+        end
+      }
+      assert_nothing_raised("Interface error for class #{placeholder_class}"){ 
+        begin
+          placeholder = placeholder_class.new( Docgenerator::Creole::Creole.new, 'a' )
+        rescue Docgenerator::Creole::Placeholder::ParameterError
+          #Docgenerator::Creole_placeholder::ParameterError is an accepted error
+          #Happens if this placeholder needs a specific parameter.
+        else
+          #Check inheritance.
+          assert_kind_of( Docgenerator::Creole::Placeholder, placeholder)
+        end
+      }
+      #Check 2 parameters
+      assert_raise(ArgumentError, "Interface error for class #{placeholder_class}"){ 
+        placeholder = placeholder_class.new( Docgenerator::Creole::Creole.new, 'a', 'b' )
+        #Check inheritance.
+        assert_kind_of( Docgenerator::Creole::Placeholder, placeholder)
+      }
+  end #do_interfacetest(key,placeholder_class)
+  
+end #class Test_creole_placeholder_interface
+
+class Test_creole_placeholders_html < Test::Unit::TestCase
+  def test_creole_placeholders_html()
+    creole = Docgenerator::Creole::Creole.new(:content => <<creole
+before
+<<<html
+<em>this is only for HTML</em>
+>>>
+after
+creole
+    )
+    #Really like this? Or should there be no paragraph?
+    assert_equal_filecontent( "expected_creole/test_creole_placeholders_html.html", creole.to_doc(:html, OPT))
+    assert_equal_filecontent( "expected_creole/test_creole_placeholders_html.latex", creole.to_doc(:latex, OPT))
+    $log.warn('test_creole_placeholders_html: to_context')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_placeholders_html.context", creole.to_doc(:context))
+    $log.warn('test_creole_placeholders_html: to wiki/creole')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_placeholders_html.creole", creole.to_doc(:creole))
+    assert_equal_filecontent( "expected_creole/test_creole_placeholders_html.text", creole.to_doc(:text, OPT))
+  end #test_creole_placeholders_html
+end #class Test_creole_placeholders_html 
+class Test_creole_placeholders_latex < Test::Unit::TestCase
+  def test_creole_placeholders_latex()
+    creole = Docgenerator::Creole::Creole.new(:content => <<creole
+before
+<<<latex
+\\textbf{this is only for latex}
+>>>
+after
+creole
+    )
+    #Really like this? Or should there be no paragraph?
+    assert_equal_filecontent( "expected_creole/test_creole_placeholders_latex.html", creole.to_doc(:html, OPT))
+    assert_equal_filecontent( "expected_creole/test_creole_placeholders_latex.latex", creole.to_doc(:latex, OPT))
+    $log.warn('test_creole_placeholders_latex: to_context')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_placeholders_context.context", creole.to_doc(:context))
+    $log.warn('test_creole_placeholders_latex: to wiki/creole')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_placeholders_latex.creole", creole.to_doc(:creole))
+    assert_equal_filecontent( "expected_creole/test_creole_placeholders_latex.text", creole.to_doc(:text, OPT))
+  end #test_creole_placeholders_latex
+end   #Test_creole_placeholders
+
+#http://www.wikicreole.org/wiki/Tables
+class Test_creole_tabular < Test::Unit::TestCase
+  def test_creole_tabular_creole()
+    creole = Docgenerator::Creole::Creole.new(
+                    :name => 'tabular_creole',
+                    :content => <<'creole'
+Tables are done like this:
+|=header col1|=header col2| 
+|col1|col2| 
+|you         |can         | 
+|also        |align\\ it. | 
+creole
+    )
+    $log.warn('test_creole_tabular_creole: tabular inside paragraphs/list...')
+    $log.warn('test_creole_tabular_creole: wiki syntax inside cell ')
+    assert_equal_filecontent( "expected_creole/test_creole_tabular_creole.html", creole.to_doc(:html, OPT))
+    assert_equal_filecontent( "expected_creole/test_creole_tabular_creole.latex", creole.to_doc(:latex, OPT))
+    $log.warn('test_creole_tabular_creole: to_context')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular_creole.context", creole.to_doc(:context))
+    $log.warn('test_creole_tabular_creole: to wiki/creole')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular_creole.creole", creole.to_doc(:creole))
+    $log.warn('test_creole_tabular_creole: to text/creole')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular_creole.text", creole.to_doc(:text))
+  end #test_creole_tabular_creole
+  
+  def test_creole_tabular()
+    creole = Docgenerator::Creole::Creole.new(:content => <<creole
+before
+<<<tabular
+|!columns=3
+|!columndescription=ccc
+|=1
+|=2
+|=3
+|-
+|eins
+|zwei
+|drei
+|-
+|one
+|two
+|three
+>>>
+after
+creole
+    )
+    assert_equal_filecontent( "expected_creole/test_creole_tabular.html", creole.to_doc(:html, OPT))
+    assert_equal_filecontent( "expected_creole/test_creole_tabular.latex", creole.to_doc(:latex, OPT))
+    $log.warn('test_creole_tabular: to_context')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular.context", creole.to_doc(:context))
+    $log.warn('test_creole_tabular: to wiki/creole')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular.creole", creole.to_doc(:creole))
+    $log.warn('test_creole_tabular: to text/creole')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular.text", creole.to_doc(:text))
+  end #test_creole_tabular
+
+  def test_creole_tabular_with_cell_option()
+#  title...    
+    creole = Docgenerator::Creole::Creole.new(:content => <<creole
+before
+<<<tabular
+|!columns=3
+|eins||css=color: red
+|css = zwei
+|||class=empty
+|-
+|normal
+|//italic//
+|//italic//||class=it
+|-
+|text with | nice! ||class = it
+|||css = 
+|
+>>>
+after
+creole
+    )
+    assert_equal_filecontent( "expected_creole/test_creole_tabular_with_cell_option.html", creole.to_doc(:html, OPT))
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular_with_option.latex", creole.to_doc(:latex))
+    $log.warn('test_creole_tabular: to_context')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular.context", creole.to_doc(:context))
+    $log.warn('test_creole_tabular: to wiki/creole')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular.creole", creole.to_doc(:creole))
+    $log.warn('test_creole_tabular: to text/creole')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular.text", creole.to_doc(:text))
+  end #test_creole_tabular
+
+  def test_creole_tabular_css()
+    creole = Docgenerator::Creole::Creole.new(:content => <<creole
+before
+<<<tabular
+|!columns=3
+|!columndescription=ccc
+|!css=border-width: 1px
+|!css=border-style: solid
+|=1
+|=2
+|=3
+|-
+|eins
+|zwei
+|drei
+|-
+|one
+|two
+|three
+>>>
+after
+creole
+    )
+    assert_equal_filecontent( "expected_creole/test_creole_tabular_css.html", creole.to_doc(:html, OPT))
+    assert_equal_filecontent( "expected_creole/test_creole_tabular_css.latex", creole.to_doc(:latex, OPT))
+    $log.warn('test_creole_tabular_css: to_context')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular_css.context", creole.to_doc(:context))
+    $log.warn('test_creole_tabular_css: to wiki/creole')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular_css.creole", creole.to_doc(:creole))
+    $log.warn('test_creole_tabular_css: to text/creole')
+    #~ assert_equal_filecontent( "expected_creole/test_creole_tabular_css.text", creole.to_doc(:text))
+  end #test_creole_tabular_css
+end   #Test_creole_tabular

data/unittest/unittest_creole_plugin_rail.rb

@@ -0,0 +1,147 @@
+#~ require '../test_docgenerator.rb'
+require 'test/unit'
+require 'more_unit_test/assert_equal_filecontent.rb'
+
+if $0 == __FILE__
+  $:.unshift("../lib")
+end
+
+require 'creole/plugins/rail.rb'
+
+#~ $log        = Log4r::Logger.new( 'test rail', Log4r::WARN )
+#~ $log.outputters = Log4r::StdoutOutputter.new('test rail')
+#~ $log.level = Log4r::INFO
+
+#~ $log.info("Remark: Known errors/problems and missing checks are logged.")
+#~ DOCGENERATOR_LOGGER.level = Log4r::DEBUG
+#~ DOCGENERATOR_LOGGER.level = Log4r::INFO
+#~ DOCGENERATOR_LOGGER.level = Log4r::WARN
+#~ DOCGENERATOR_LOGGER.level = Log4r::ERROR
+
+#~ include Log4r 
+
+#~ class Test_rail < Test::Unit::TestCase
+  #~ def test_rail()
+    #~ block = Rail_diagramm.new('block', <<-RAIL
+        #~ ( lbrace | 'begin' )
+        #~ ( ( '|' ( variable + ',' ) '|' ) | [Keine Blockvariablen] )
+        #~ comm
+        #~ ( rbrace | 'end' )
+      #~ RAIL
+      #~ )
+  #~ assert_equal_filecontent( "expected_rail/rail_.rail", text.to_doc(:tex))
+  #~ end
+#~ end #Test_rail
+
+class Test_creole_rail < Test::Unit::TestCase
+  def test_document_placeholder()
+    doc = Docgenerator::Creole::Creole_document.new(
+      :title => 'Rail-Diagramms in Creole'
+    )
+    assert_nothing_raised(){
+      doc  << <<DATA
+<<<rail|id
+A
+>>>
+DATA
+    }    
+  end
+  def test_document_placeholder_missing_id()
+    doc = Docgenerator::Creole::Creole_document.new(
+      :title => 'Rail-Diagramms in Creole'
+    )
+    assert_raise( Docgenerator::Creole::Placeholder::ParameterError ){
+      doc  << <<DATA
+<<<rail
+A
+>>>
+DATA
+    }    
+  end
+  def test_document_placeholder_wrong_id()
+    doc = Docgenerator::Creole::Creole_document.new(
+      :title => 'Rail-Diagramms in Creole'
+    )
+    assert_raise( Docgenerator::Creole::Placeholder::ParameterError ){
+      doc  << <<DATA
+<<<rail|id-with-minus
+A
+>>>
+DATA
+    }    
+  end
+  
+  def test_document_placeholder_in_wiki()
+    doc = Docgenerator::Creole::Creole_document.new(
+      :title => 'Rail-Diagramms in Creole'
+    )
+    doc.doc.head << Docgenerator::Creole::Rail::Rail_diagramm::TEX_PACKAGE_RAIL
+    #~ doc.doc.head << element(:latexonly,{}, [
+      #~ Rail_diagramm::RAIL_ALIAS,
+      #~ '\railterm{lowcharacter,uppercharacter}',
+      #~ ])
+
+    doc  << <<DATA
+=Rail-Diagramms
+==Via Placeholder
+<<<rail|test
+      [1] (
+            ( '[' string ']' )
+           ? body[2--6] + '|'
+           )
+    | [2] body[3--6] '*' body[5--6]
+    | [2] body[3--6] '+' body[5--6]
+    | [3] ( body[4--5] + )
+    | [4] body[5] '?'
+    | [5] identifier ( '[' string ']' ) ?
+    | [5] quote string quote
+    | [5] dquote string dquote
+    | [5] '(' body[1--6] ')'
+    | [5] cr
+    | [6]
+    ;
+>>>
+DATA
+#~ doc.runtex = :pdflatex
+  assert_equal_filecontent( "expected_creole_rail/test_rail_creole_placeholder.tex", doc.doc.to_latex({
+                                              :template=> Docgenerator::DocumentTemplate[:article],
+                                              :filename => 'xx',
+                                              :log  => doc.doc.log
+                                            }))
+  end
+                                          
+                                          
+  def test_document_object()
+    $block = Docgenerator::Creole::Rail::Rail_diagramm.new('block', <<-RAIL
+        ( lbrace | 'begin' )
+        ( ( '|' ( variable + ',' ) '|' ) | [Keine Blockvariablen] )
+        comm
+        ( rbrace | 'end' )
+      RAIL
+      )
+    doc = Docgenerator::Creole::Creole_document.new(
+      :title => 'Rail-Diagramms in Creole'
+    )
+    doc.doc.head << Docgenerator::Creole::Rail::Rail_diagramm::TEX_PACKAGE_RAIL
+    #~ doc.doc.head << element(:latexonly,{}, [
+      #~ Rail_diagramm::RAIL_ALIAS,
+      #~ '\railterm{lowcharacter,uppercharacter}',
+      #~ ])
+
+    doc  << <<DATA
+=Rail-Diagramms
+==Via Ruby-object
+<<ruby_raw|$block.to_latex>>
+DATA
+#~ doc.runtex = :pdflatex
+    assert_equal_filecontent( "expected_creole_rail/test_rail_creole_object.tex", doc.doc.to_latex({
+                                              :template=> Docgenerator::DocumentTemplate[:article],
+                                              :filename => 'xx',                                              
+                                              :log  => doc.doc.log
+                                            }))
+  end
+end #Test_rail
+
+  #~ assert_equal_filecontent( "expected_rail/rail_.rail", text.to_doc(:tex))
+
+__END__

data/unittest/unittest_docgenerator.rb

@@ -1,57 +1,66 @@
 # encoding: utf-8
+gem 'test-unit'
 require 'test/unit'
-$:.unshift('C:/usr/Script/more_unit_test/lib')
+#~ $:.unshift('C:/usr/Script/more_unit_test/lib')
 require 'more_unit_test/assert_equal_filecontent.rb'
 
 if $0 == __FILE__
   $:.unshift("../lib")
 end
 require 'docgenerator'
+include Docgenerator
+#~ DOCGENERATOR_LOGGER.level = Log4r::DEBUG
 
 #~ Element::SUPPORTED_TARGETS << :context 
 #~ Element::SUPPORTED_TARGETS << :creole
-#~ DOCGENERATOR_LOGGER.level = Log4r::DEBUG
-#~ DOCGENERATOR_LOGGER.level = Log4r::ERROR
 
 $log = Log4r::Logger.new('Unittest docgenerator', Log4r::ERROR )
+$log.freeze
 #~ $log = Log4r::Logger.new('Unittest docgenerator', Log4r::WARN)
 #~ $log = Log4r::Logger.new('Unittest docgenerator', Log4r::INFO)
 $log.outputters = Log4r::StdoutOutputter.new('log_stdout')
 
-require 'tempfile'  #needed to get logger.data
-#
-#Two methods to catch and check logger content.
-module Temp_Logger
-  #Redirect Logger data to temporary file
-  def set_temporary_logger( level = Log4r::WARN )
-    templogfile = Tempfile.new("xxx_warn.log")
-    @loglevel = DOCGENERATOR_LOGGER.level
-    @outputter = DOCGENERATOR_LOGGER.outputters.first
-    DOCGENERATOR_LOGGER.level = level
-    DOCGENERATOR_LOGGER.outputters = Log4r::IOOutputter.new('log_xxx', templogfile )
-    return templogfile
-  end
-  #Get temporary data and reset logger.
-  def get_temporary_logger(templogfile)
-    templogfile.close()
-    templogfile.open()
-    templogfile_content = templogfile.readlines.join()
-    templogfile.close(true)    
-    DOCGENERATOR_LOGGER.level = @loglevel 
-    DOCGENERATOR_LOGGER.outputters = @outputter
-    return templogfile_content
+=begin rdoc
+Define a new outputter to catch data into an array
+=end
+class ArrayOutputter < Log4r::StdoutOutputter
+=begin rdoc
+Collect messages in array.
+=end
+  def write(message)
+    @messages ||= []  #create with first call
+    @messages  << message
   end
-end
+=begin rdoc
+Clear message array and return messages
+=end
+  def flush
+    @messages ||= []  #create with first call
+    messages = @messages.dup
+    @messages.clear
+    messages
+  end
+end #ArrayOutputter
+
+$log_array = Log4r::Logger.new('docgenerator', Log4r::DEBUG)
+$log_array.outputters = $log_array_outputter = ArrayOutputter.new('xx')
 
 
 
 class Test_elements < Test::Unit::TestCase
-  include Temp_Logger
+  def setup()
+    #Avoid warnings about missing logger in to_doc
+    @opt = { :log => DOCGENERATOR_DEFAULT_LOGGER } #unless defined? @opt
+  end
   def test_generell_settings()
     #Check the logger
     assert_instance_of( Log4r::Logger, DOCGENERATOR_LOGGER)
-    assert_equal( Log4r::FATAL, DOCGENERATOR_LOGGER.level, "Default Level of Default-Logger (DOCGENERATOR_LOGGER) changed:")
-    #~ assert_equal( Log4r::ERROR, DOCGENERATOR_LOGGER.level)
+    
+    assert_equal( Log4r::ERROR, DOCGENERATOR_LOGGER.level, "Default Level of Default-Logger (DOCGENERATOR_LOGGER) changed:")
+    #Check the default logger
+    assert_instance_of( Log4r::Logger, DOCGENERATOR_DEFAULT_LOGGER)
+    assert_equal( Log4r::WARN, DOCGENERATOR_DEFAULT_LOGGER.level, "Default Level of Default-Logger (DOCGENERATOR_DEFAULT_LOGGER) changed:")
+    
     assert_instance_of( Log4r::StdoutOutputter, DOCGENERATOR_LOGGER.outputters.first)
     #~ assert_equal( Log4r::FATAL, DOCGENERATOR_LOGGER.outputters.first.level)
   end
@@ -63,193 +72,32 @@ class Test_elements < Test::Unit::TestCase
 
     assert_equal( true, element(:p).content?)
     assert_equal( false, element(:br).content?)
-    #Result ok, but warning
-    assert_equal( "<br />", element(:br,{},'content').to_html)
     
-    #fixme Umsetzen des logger in methoden
-    templogfile = set_temporary_logger()
-    assert_equal( "<br />", element(:br,{},'content').to_html)
+    #Result ok, but warning
+    assert_equal( "<br />", element(:br,{log: $log_array},'content').to_html(@opt))
     #~ assert_equal_filecontent( "expected/test_content.log", get_temporary_logger() )
     #Problem: ids.inspect is unsorted -> check only match
-    #~ assert_equal(%Q{ WARN docgenerator: Add content to an element without this feature ["br/", :br, :newline, "br"], "content"\n},  get_temporary_logger(templogfile))
-    assert_match(%r{WARN docgenerator: Add content to an element without this feature \[(.*):newline(.*)\], "content"\n},  get_temporary_logger(templogfile))
+    #~ assert_equal(%Q{ WARN docgenerator: Add content to an element without this feature ["br/", :br, :newline, "br"], "content"\n},  $log_array_outputter.flush.join)
+    assert_match(%r{WARN docgenerator: Add content to an element without this feature <Docgenerator::Elements::Newline.*>, "content"\n},  
+          $log_array_outputter.flush.join)
   end
-  def test_symbols()
-    #~ log = Log4r::Logger.new( 'section_logger')
-    #~ log.level = Log4r::ERROR
-    #~ log.level = Log4r::DEBUG
-    #~ log.outputters = Log4r::StdoutOutputter.new('test_section')
-    assert_equal( '&ensp;', element(:space).to_html)
-    assert_equal( '&ensp;', element(:ensp).to_html)
-    assert_equal( '~', element(:space).to_latex)
-    #~ assert_equal( '??', element(:space).to_context)
-    assert_equal( '~', element(:ensp).to_latex)
-    #~ assert_equal( '??', element(:ensp).to_context)
-    assert_equal( '&emsp;', element(:bigspace).to_html)
-    assert_equal( '&emsp;', element(:emsp).to_html)
-    assert_equal( '~~', element(:bigspace).to_latex)
-    #~ assert_equal( '??', element(:bigspace).to_context)
-    assert_equal( '~~', element(:emsp).to_latex)
-    #~ assert_equal( '??', element(:emsp).to_context)
-    assert_equal( '&nbsp;', element(:nbsp).to_html)
-    assert_equal( '~', element(:nbsp).to_latex)
-    #~ assert_equal( '??', element(:nbsp).to_context)
-    assert_equal( '&euro;', element(:euro).to_html)
-    assert_equal( '\euro', element(:euro).to_latex)
-    #~ assert_equal( '??', element(:euro).to_context)
-    assert_equal( '%', element(:percent).to_html)
-    assert_equal( '%', element(:'%').to_html)
-    assert_equal( '\%', element(:percent).to_latex)
-    #~ assert_equal( '??', element(:percent).to_context)
-    assert_equal( '\%', element(:'%').to_latex)
-    #~ assert_equal( '??', element(:'%').to_context)
-    assert_equal( '^', element(:'^').to_html)
-    assert_equal( '\hat{}', element(:'^').to_latex)
-    #~ assert_equal( '??', element(:'^').to_context)
-    assert_equal( '&iquest;', element(:iquest).to_html)
-    assert_equal( '¿', element(:iquest).to_latex)
-    #~ assert_equal( '??', element(:iquest).to_context)
-    assert_equal( '&amp;', element(:ampersand).to_html)
-    assert_equal( '&amp;', element(:'&').to_html)
-    assert_equal( '\&', element(:ampersand).to_latex)
-    #~ assert_equal( '??', element(:ampersand).to_context)
-    assert_equal( '\&', element(:'&').to_latex)
-    #~ assert_equal( '??', element(:'&').to_context)
-    assert_equal( '}', element(:rbrace).to_html)
-    assert_equal( '}', element(:'}').to_html)
-    assert_equal( '\}', element(:rbrace).to_latex)
-    #~ assert_equal( '??', element(:rbrace).to_context)
-    assert_equal( '\}', element(:'}').to_latex)
-    #~ assert_equal( '??', element(:'}').to_context)
-    assert_equal( '{', element(:lbrace).to_html)
-    assert_equal( '{', element(:'{').to_html)
-    assert_equal( '\{', element(:lbrace).to_latex)
-    #~ assert_equal( '??', element(:lbrace).to_context)
-    assert_equal( '\{', element(:'{').to_latex)
-    #~ assert_equal( '??', element(:'{').to_context)
-    assert_equal( '\\', element(:backslash).to_html)
-    assert_equal( '\ensuremath{\backslash}', element(:backslash).to_latex)
-    #~ assert_equal( '??', element(:backslash).to_context)
-    assert_equal( '&radic;', element(:radic).to_html)
-    assert_equal( '\ensuremath{\sqrt{}}', element(:radic).to_latex)
-    #~ assert_equal( '??', element(:radic).to_context)
-    assert_equal( '&rarr;', element(:rarr).to_html)
-    assert_equal( '&rarr;', element(:rightarrow).to_html)
-    assert_equal( '&rarr;', element(:'->').to_html)
-    assert_equal( '->', element(:'->').to_text)
-    assert_equal( '\ensuremath{\rightarrow}', element(:rarr).to_latex)
-    #~ assert_equal( '??', element(:rarr).to_context)
-    assert_equal( '\ensuremath{\rightarrow}', element(:rightarrow).to_latex)
-    #~ assert_equal( '??', element(:rightarrow).to_context)
-    assert_equal( '\ensuremath{\rightarrow}', element(:'->').to_latex)
-    #~ assert_equal( '??', element(:'->').to_context)
-    assert_equal( '&rArr;', element(:rArr).to_html)
-    assert_equal( '&rArr;', element(:Rightarrow).to_html)
-    assert_equal( '&rArr;', element(:'=>').to_html)
-    assert_equal( '=>', element(:'=>').to_text)
-    assert_equal( '\ensuremath{\Rightarrow}', element(:rArr).to_latex)
-    #~ assert_equal( '??', element(:rArr).to_context)
-    assert_equal( '\ensuremath{\Rightarrow}', element(:Rightarrow).to_latex)
-    #~ assert_equal( '??', element(:Rightarrow).to_context)
-    assert_equal( '\ensuremath{\Rightarrow}', element(:'=>').to_latex)
-    #~ assert_equal( '??', element(:'=>').to_context)
-    assert_equal( '&larr;', element(:larr).to_html)
-    assert_equal( '&larr;', element(:leftarrow).to_html)
-    assert_equal( '&larr;', element(:'<-').to_html)
-    assert_equal( '<-', element(:'<-').to_text)
-    assert_equal( '\ensuremath{\leftarrow}', element(:larr).to_latex)
-    #~ assert_equal( '??', element(:larr).to_context)
-    assert_equal( '\ensuremath{\leftarrow}', element(:leftarrow).to_latex)
-    #~ assert_equal( '??', element(:leftarrow).to_context)
-    assert_equal( '\ensuremath{\leftarrow}', element(:'<-').to_latex)
-    #~ assert_equal( '??', element(:'<-').to_context)
-    assert_equal( '&lArr;', element(:lArr).to_html)
-    assert_equal( '&lArr;', element(:Leftarrow).to_html)
-    assert_equal( '&lArr;', element(:'<=').to_html)
-    assert_equal( '<=', element(:'<=').to_text)
-    assert_equal( '\ensuremath{\Lefttarrow}', element(:lArr).to_latex)
-    #~ assert_equal( '??', element(:lArr).to_context)
-    assert_equal( '\ensuremath{\Lefttarrow}', element(:Leftarrow).to_latex)
-    #~ assert_equal( '??', element(:Leftarrow).to_context)
-    assert_equal( '\ensuremath{\Lefttarrow}', element(:'<=').to_latex)
-    #~ assert_equal( '??', element(:'<=').to_context)
-    assert_equal( '&uArr;', element(:uArr).to_html)
-    assert_equal( '&uArr;', element(:Uparrow).to_html)
-    assert_equal( '\ensuremath{\Uparrow}', element(:uArr).to_latex)
-    #~ assert_equal( '??', element(:uArr).to_context)
-    assert_equal( '\ensuremath{\Uparrow}', element(:Uparrow).to_latex)
-    #~ assert_equal( '??', element(:Uparrow).to_context)
-    assert_equal( '&lt;', element(:lt).to_html)
-    assert_equal( '&lt;', element(:'<').to_html)
-    assert_equal( '\ensuremath{<}', element(:lt).to_latex)
-    #~ assert_equal( '??', element(:lt).to_context)
-    assert_equal( '\ensuremath{<}', element(:'<').to_latex)
-    #~ assert_equal( '??', element(:'<').to_context)
-    assert_equal( '&gt;', element(:gt).to_html)
-    assert_equal( '&gt;', element(:'>').to_html)
-    assert_equal( '\ensuremath{>}', element(:gt).to_latex)
-    #~ assert_equal( '??', element(:gt).to_context)
-    assert_equal( '\ensuremath{>}', element(:'>').to_latex)
-    #~ assert_equal( '??', element(:'>').to_context)
-    assert_equal( '&infin;', element(:infin).to_html)
-    assert_equal( '&infin;', element(:infty).to_html)
-    assert_equal( '\ensuremath{\infty}', element(:infin).to_latex)
-    #~ assert_equal( '??', element(:infin).to_context)
-    assert_equal( '\ensuremath{\infty}', element(:infty).to_latex)
-    #~ assert_equal( '??', element(:infty).to_context)
-    assert_equal( '&divide;', element(:divide).to_html)
-    assert_equal( '\ensuremath{\div}', element(:divide).to_latex)
-    #~ assert_equal( '??', element(:divide).to_context)
-    assert_equal( '&yen;', element(:yen).to_html)
-    assert_equal( '&sim;', element(:sim).to_html)
-    assert_equal( '\ensuremath{\sim}', element(:sim).to_latex)
-    #~ assert_equal( '??', element(:sim).to_context)
-    assert_equal( '&brvbar;', element(:brvbar).to_html)
-    assert_equal( '|', element(:brvbar).to_latex)
-    #~ assert_equal( '??', element(:brvbar).to_context)
-    assert_equal( '5&euro;', element(:euros,{},5).to_html)
-    assert_equal( '\euros{5}', element(:euros,{},5).to_latex)
-    #~ assert_equal( '??', element(:euros,{},5).to_context)
-    assert_equal( '&not;', element(:neg).to_html)
-    assert_equal( '&not;', element(:not).to_html)
-    assert_equal( '\ensuremath{\neg}', element(:neg).to_latex)
-    #~ assert_equal( '??', element(:neg).to_context)
-    assert_equal( '\ensuremath{\neg}', element(:not).to_latex)
-    #~ assert_equal( '??', element(:not).to_context)
-    assert_equal( '&times;', element(:times).to_html)
-    assert_equal( '\ensuremath{\times}', element(:times).to_latex)
-    #~ assert_equal( '??', element(:times).to_context)
-    assert_equal( '&otimes;', element(:otimes).to_html)
-    assert_equal( '\ensuremath{\otimes}', element(:otimes).to_latex)
-    #~ assert_equal( '??', element(:otimes).to_context)
-    assert_equal( '&empty;', element(:empty).to_html)
-    assert_equal( '\ensuremath{\emptyset}', element(:empty).to_latex)
-    #~ assert_equal( '??', element(:empty).to_context)
-    assert_equal( '_', element(:'_').to_html)
-    assert_equal( '_', element(:underscore).to_html)
-    assert_equal( '\_', element(:'_').to_latex)
-    #~ assert_equal( '??', element(:'_').to_context)
-    assert_equal( '\_', element(:underscore).to_latex)
-    #~ assert_equal( '??', element(:underscore).to_context)
-    assert_equal( '&#149;', element(:bullet).to_html)
-    assert_equal( '\ensuremath{\bullet}', element(:bullet).to_latex)
-    #~ assert_equal( '??', element(:bullet).to_context)
-    assert_equal( '&ndash;', element(:'--').to_html)
-    assert_equal( '&ndash;', element(:ndash).to_html)
-    assert_equal( '--', element(:'--').to_latex)
-    #~ assert_equal( '??', element(:'??').to_context)
-    assert_equal( '--', element(:ndash).to_latex)
-    #~ assert_equal( '??', element(:ndash).to_context)
-    assert_equal( '&mdash;', element(:'---').to_html)
-    assert_equal( '&mdash;', element(:mdash).to_html)
-    assert_equal( '---', element(:'---').to_latex)
-    #~ assert_equal( '??', element(:'??').to_context)
-    assert_equal( '---', element(:mdash).to_latex)
-    #~ assert_equal( '??', element(:mdash).to_context)
-    assert_equal( '&dagger;', element(:dagger).to_html)
-    assert_equal( '\dag', element(:dagger).to_latex)
-    #~ assert_equal( '??', element(:dagger).to_context)
+  def test_is_a()
+
+    newline = element(:br)
+    assert_true( newline.is_a?(Element) )
+    assert_true( newline.is_a?(:br) )
+    assert_true( newline.is_a?(:newline) )
+    
+    assert_false( newline.is_a?(:zeilenumbruch) )
+    assert_false( newline.is_a?(Symbol) )
+    assert_false( newline.is_a?(Array) )
+
+    #Standard behaviour: TypeError: class or module required
+    assert_false( newline.to_html(@opt).is_a?(:newline) )
+    assert_false( '<br />'.is_a?(:newline) )
+
   end
+  
   def test_section()
     #~ log = Log4r::Logger.new( 'section_logger')
     #~ log.level = Log4r::ERROR
@@ -266,14 +114,14 @@ class Test_elements < Test::Unit::TestCase
       element(:h2, {}, 'Abschnitt 2.1' ).cr,
       element(:p, {}, 'Text zu Abschnitt 2.1' ).cr
     ]
-    assert_equal_filecontent( "expected/test_section.html", text.to_doc(:html))
-    assert_equal_filecontent( "expected/test_section.latex", text.to_doc(:latex))
+    assert_equal_filecontent( "expected/test_section.html", text.to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_section.latex", text.to_doc(:latex, @opt))
     $log.warn('test_section: to_context')
-    #~ assert_equal_filecontent( "expected/test_section.context", text.to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_section.context", text.to_doc(:context, @opt))
     $log.warn('test_section: to_creole')
-    #~ assert_equal_filecontent( "expected/test_section.creole", text.to_doc(:creole))
-    assert_equal_filecontent( "expected/test_section.wiki", text.to_doc(:wiki))
-    assert_equal_filecontent( "expected/test_section.text", text.to_doc(:text))
+    #~ assert_equal_filecontent( "expected/test_section.creole", text.to_doc(:creole, @opt))
+    assert_equal_filecontent( "expected/test_section.wiki", text.to_doc(:wiki,@opt))
+    assert_equal_filecontent( "expected/test_section.text", text.to_doc(:text, @opt))
   end
   def test_href()
     #~ log = Log4r::Logger.new( 'section_logger')
@@ -290,59 +138,67 @@ class Test_elements < Test::Unit::TestCase
           element(:a, {:href=>'#ilink'}, 'target.'),
           ] ).cr,
     ]
-    assert_equal_filecontent( "expected/test_href.html", text.to_doc(:html))
-    assert_equal_filecontent( "expected/test_href.latex", text.to_doc(:latex))
+    assert_equal_filecontent( "expected/test_href.html", text.to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_href.latex", text.to_doc(:latex, @opt))
     $log.warn('test_href: to_context')
-    #~ assert_equal_filecontent( "expected/test_href.context", text.to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_href.context", text.to_doc(:context, @opt))
     $log.warn('test_href: to_creole')
-    #~ assert_equal_filecontent( "expected/test_href.creole", text.to_doc(:creole))
-    #~ assert_equal_filecontent( "expected/test_href.wiki", text.to_doc(:wiki))
-    assert_equal_filecontent( "expected/test_href.text", text.to_doc(:text))  #not good
+    #~ assert_equal_filecontent( "expected/test_href.creole", text.to_doc(:creole, @opt))
+    #~ assert_equal_filecontent( "expected/test_href.wiki", text.to_doc(:wiki,@opt))
+    assert_equal_filecontent( "expected/test_href.text", text.to_doc(:text, @opt))  #not good
   end
 end #Test_elements 
 
 class Test_lists < Test::Unit::TestCase
+  def setup()
+    #Avoid warnings about missing logger in to_doc
+    @opt = { :log => DOCGENERATOR_DEFAULT_LOGGER } #unless defined? @opt
+  end
   def test_itemize
     ul = element(:ul, {}, [
                 element(:li, {}, 'Listpunkt 1'),
         ])
-    assert_equal_filecontent( "expected/test_itemize.html", ul.to_doc(:html))
-    assert_equal_filecontent( "expected/test_itemize.latex", ul.to_doc(:latex))
-    assert_equal_filecontent( "expected/test_itemize.context", ul.to_doc(:context))
+    assert_equal_filecontent( "expected/test_itemize.html", ul.to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_itemize.latex", ul.to_doc(:latex, @opt))
+    assert_equal_filecontent( "expected/test_itemize.context", ul.to_doc(:context, @opt))
     $log.warn('test_itemize: to_creole')
-    #~ assert_equal_filecontent( "expected/test_itemize.creole", ul.to_doc(:creole))
-    assert_equal_filecontent( "expected/test_itemize.wiki", ul.to_doc(:wiki))
-    assert_equal_filecontent( "expected/test_itemize.text", ul.to_doc(:text))
+    #~ assert_equal_filecontent( "expected/test_itemize.creole", ul.to_doc(:creole, @opt))
+    assert_equal_filecontent( "expected/test_itemize.wiki", ul.to_doc(:wiki,@opt))
+    assert_equal_filecontent( "expected/test_itemize.text", ul.to_doc(:text, @opt))
   end
   def test_enumerate
     ol = element(:ol, {}, [
                 element(:li, {}, 'Listpunkt 1'),
         ])
-    assert_equal_filecontent( "expected/test_enumerate.html", ol.to_doc(:html))
-    assert_equal_filecontent( "expected/test_enumerate.latex", ol.to_doc(:latex))
-    assert_equal_filecontent( "expected/test_enumerate.context", ol.to_doc(:context))
+    assert_equal_filecontent( "expected/test_enumerate.html", ol.to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_enumerate.latex", ol.to_doc(:latex, @opt))
+    assert_equal_filecontent( "expected/test_enumerate.context", ol.to_doc(:context, @opt))
     $log.warn('test_enumerate: to_creole')
-    #~ assert_equal_filecontent( "expected/test_enumerate.creole", ol.to_doc(:creole))
-    assert_equal_filecontent( "expected/test_enumerate.wiki", ol.to_doc(:wiki))
-    assert_equal_filecontent( "expected/test_enumerate.text", ol.to_doc(:text))
+    #~ assert_equal_filecontent( "expected/test_enumerate.creole", ol.to_doc(:creole, @opt))
+    assert_equal_filecontent( "expected/test_enumerate.wiki", ol.to_doc(:wiki,@opt))
+    assert_equal_filecontent( "expected/test_enumerate.text", ol.to_doc(:text, @opt))
   end
   def test_description
     description = element(:description, {}, [
                 element(:dt, {}, 'Top 1'),
                 element(:dd, {}, 'Listpunkt 1'),
         ])
-    assert_equal_filecontent( "expected/test_description.html", description.to_doc(:html))
-    assert_equal_filecontent( "expected/test_description.latex", description.to_doc(:latex))
+    assert_equal_filecontent( "expected/test_description.html", description.to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_description.latex", description.to_doc(:latex, @opt))
     $log.warn('test_description: to_context')
-    #~ assert_equal_filecontent( "expected/test_description.context", description.to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_description.context", description.to_doc(:context, @opt))
     $log.warn('test_description: to_creole')
-    #~ assert_equal_filecontent( "expected/test_description.creole", description.to_doc(:creole))
-    assert_equal_filecontent( "expected/test_description.wiki", description.to_doc(:wiki))
-    assert_equal_filecontent( "expected/test_description.text", description.to_doc(:text))
+    #~ assert_equal_filecontent( "expected/test_description.creole", description.to_doc(:creole, @opt))
+    assert_equal_filecontent( "expected/test_description.wiki", description.to_doc(:wiki,@opt))
+    assert_equal_filecontent( "expected/test_description.text", description.to_doc(:text, @opt))
   end
 end #Test_lists 
 
 class Test_footnotes < Test::Unit::TestCase
+  def setup()
+    #Avoid warnings about missing logger in to_doc
+    @opt = { :log => DOCGENERATOR_DEFAULT_LOGGER } #unless defined? @opt
+  end
   def test_footnote
     footnotegroup = Footnotegroup.new()
     #~ footnotegroup = nil
@@ -357,14 +213,14 @@ class Test_footnotes < Test::Unit::TestCase
       element(:h2, {}, 'Footnotes' ).cr,
       footnotegroup,
     ]
-    assert_equal_filecontent( "expected/test_footnote.html", text.to_doc(:html))
-    assert_equal_filecontent( "expected/test_footnote.latex", text.to_doc(:latex))
+    assert_equal_filecontent( "expected/test_footnote.html", text.to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_footnote.latex", text.to_doc(:latex, @opt))
     $log.warn('test_footnote: to_context')
-    #~ assert_equal_filecontent( "expected/test_footnote.context", text.to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_footnote.context", text.to_doc(:context, @opt))
     $log.warn('test_footnote: to_creole')
-    #~ assert_equal_filecontent( "expected/test_footnote.creole", text.to_doc(:creole))
-    #~ assert_equal_filecontent( "expected/test_footnote.wiki", text.to_doc(:wiki))
-    #~ assert_equal_filecontent( "expected/test_footnote.text", text.to_doc(:text))
+    #~ assert_equal_filecontent( "expected/test_footnote.creole", text.to_doc(:creole, @opt))
+    #~ assert_equal_filecontent( "expected/test_footnote.wiki", text.to_doc(:wiki,@opt))
+    #~ assert_equal_filecontent( "expected/test_footnote.text", text.to_doc(:text, @opt))
   end #test_footnote
   def test_footnote_group
     footnotegroup   = Footnotegroup.new()
@@ -383,18 +239,22 @@ class Test_footnotes < Test::Unit::TestCase
       element(:h3, {}, 'Footnotes of group 1' ).cr,      
       footnotegroup2,
     ]
-    assert_equal_filecontent( "expected/test_footnote_group.html", text.to_doc(:html))
-    assert_equal_filecontent( "expected/test_footnote_group.latex", text.to_doc(:latex))
+    assert_equal_filecontent( "expected/test_footnote_group.html", text.to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_footnote_group.latex", text.to_doc(:latex, @opt))
     $log.warn('test_footnote_group: to_context')
-    #~ assert_equal_filecontent( "expected/test_footnote_group.context", text.to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_footnote_group.context", text.to_doc(:context, @opt))
     $log.warn('test_footnote_group: to_creole')
-    #~ assert_equal_filecontent( "expected/test_footnote_group.creole", text.to_doc(:creole))
-    #~ assert_equal_filecontent( "expected/test_footnote_group.wiki", text.to_doc(:wiki))
-    #~ assert_equal_filecontent( "expected/test_footnote_group.text", text.to_doc(:text))
+    #~ assert_equal_filecontent( "expected/test_footnote_group.creole", text.to_doc(:creole, @opt))
+    #~ assert_equal_filecontent( "expected/test_footnote_group.wiki", text.to_doc(:wiki,@opt))
+    #~ assert_equal_filecontent( "expected/test_footnote_group.text", text.to_doc(:text, @opt))
   end #test_footnote
 end #Test_footnotes
 
 class Test_tabular < Test::Unit::TestCase
+  def setup()
+    #Avoid warnings about missing logger in to_doc
+    @opt = { :log => DOCGENERATOR_DEFAULT_LOGGER } #unless defined? @opt
+  end
   def mk_tabular( columns, lines )
     
     tab = element(:tabular, {
@@ -425,23 +285,23 @@ class Test_tabular < Test::Unit::TestCase
   end
   def test_tabular()
     text = mk_tabular( Array('A'..'D'), Array(1..5) )
-    assert_equal_filecontent( "expected/test_tabular.html", text.to_doc(:html))
+    assert_equal_filecontent( "expected/test_tabular.html", text.to_doc(:html, @opt))
     #The line ends will be \\\\
     #In usage in documents, it's converted into \\.
     #
     #~ doc = Document.new()
-    #~ doc.body << text.to_doc(:latex)
+    #~ doc.body << text.to_doc(:latex, @opt)
     #~ doc.save('Test.tex')  #\\ is ok
     #
     #~ $fixmes << "tabular/latex: tablines line 229 ../lib/docgenerator_tabular.rb#229"
-    assert_equal_filecontent( "expected/test_tabular.latex", text.to_doc(:latex))
+    assert_equal_filecontent( "expected/test_tabular.latex", text.to_doc(:latex, @opt))
     $log.warn('test_tabular: to_context')
-    #~ assert_equal_filecontent( "expected/test_tabular.context", text.to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_tabular.context", text.to_doc(:context, @opt))
     $log.warn('test_tabular: to_creole')
-    #~ assert_equal_filecontent( "expected/test_tabular.creole", text.to_doc(:creole))
-    assert_equal_filecontent( "expected/test_tabular.wiki", text.to_doc(:wiki))
+    #~ assert_equal_filecontent( "expected/test_tabular.creole", text.to_doc(:creole, @opt))
+    assert_equal_filecontent( "expected/test_tabular.wiki", text.to_doc(:wiki,@opt))
     $log.warn("text-output for tables")
-    #~ assert_equal_filecontent( "expected/test_tabular.text", text.to_doc(:text))
+    #~ assert_equal_filecontent( "expected/test_tabular.text", text.to_doc(:text, @opt))
   end
   def test_tabular_doc()
     doc = Document.new()
@@ -451,7 +311,7 @@ class Test_tabular < Test::Unit::TestCase
     #~ doc.log.outputters = Log4r::StdoutOutputter.new('test_section')
     #~ doc.log.level = Log4r::INFO
     
-    #~ assert_equal_filecontent( "expected/test_tabular_doc.html", text.to_doc(:html))
+    #~ assert_equal_filecontent( "expected/test_tabular_doc.html", text.to_doc(:html, @opt))
     
     #The row ends in tabulars are \\.
     #When used in documents, \\ is  converted into \.
@@ -459,45 +319,52 @@ class Test_tabular < Test::Unit::TestCase
     assert_equal_filecontent( "expected/test_tabular_doc.latex", doc.to_doc(:latex, 
                 { :log => doc.log, :template=> DocumentTemplate[:article], :filename => 'test'}
                 ) )
-    #~ assert_equal_filecontent( "expected/test_tabular_doc.wiki", text.to_doc(:wiki))
-    #~ assert_equal_filecontent( "expected/test_tabular_doc.text", text.to_doc(:text))
+    #~ assert_equal_filecontent( "expected/test_tabular_doc.wiki", text.to_doc(:wiki,@opt))
+    #~ assert_equal_filecontent( "expected/test_tabular_doc.text", text.to_doc(:text, @opt))
   end
 end
 
 
 class Test_Verbatim < Test::Unit::TestCase
-    def test_verbatim()
+   def setup()
+    #Avoid warnings about missing logger in to_doc
+    @opt = { :log => DOCGENERATOR_DEFAULT_LOGGER } #unless defined? @opt
+  end
+   def test_verbatim()
     text = element(:verbatim,{}, <<verb
 Verbatim text
 second line
 verb
 )
-    assert_equal_filecontent( "expected/test_verbatim.html", text.to_doc(:html))
-    assert_equal_filecontent( "expected/test_verbatim.latex", text.to_doc(:latex))
+    assert_equal_filecontent( "expected/test_verbatim.html", text.to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_verbatim.latex", text.to_doc(:latex, @opt))
     $log.warn('test_verbatim: to_context')
-    #~ assert_equal_filecontent( "expected/test_verbatim.context", text.to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_verbatim.context", text.to_doc(:context, @opt))
     $log.warn('test_verbatim: to_creole/to_wiki')
-    #~ assert_equal_filecontent( "expected/test_verbatim.creole", text.to_doc(:creole))
-    #~ assert_equal_filecontent( "expected/test_verbatim.wiki", text.to_doc(:wiki))
+    #~ assert_equal_filecontent( "expected/test_verbatim.creole", text.to_doc(:creole, @opt))
+    #~ assert_equal_filecontent( "expected/test_verbatim.wiki", text.to_doc(:wiki,@opt))
     $log.warn("text-output for verbatim")
-    #~ assert_equal_filecontent( "expected/test_verbatim.text", text.to_doc(:text))
+    #~ assert_equal_filecontent( "expected/test_verbatim.text", text.to_doc(:text, @opt))
   end
   def test_verbatim_array()
     text = element(:verbatim,{}, %w{Verbatim text second line})
-    assert_equal_filecontent( "expected/test_verbatim_array.html", text.to_doc(:html))
-    assert_equal_filecontent( "expected/test_verbatim_array.latex", text.to_doc(:latex))
+    assert_equal_filecontent( "expected/test_verbatim_array.html", text.to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_verbatim_array.latex", text.to_doc(:latex, @opt))
     $log.warn('test_verbatim_array: to_context')
-    #~ assert_equal_filecontent( "expected/test_verbatim.context", text.to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_verbatim.context", text.to_doc(:context, @opt))
     $log.warn('test_verbatim_array: to_creole/to_wiki')
-    #~ assert_equal_filecontent( "expected/test_verbatim.creole", text.to_doc(:creole))
-    #~ assert_equal_filecontent( "expected/test_verbatim.wiki", text.to_doc(:wiki))
+    #~ assert_equal_filecontent( "expected/test_verbatim.creole", text.to_doc(:creole, @opt))
+    #~ assert_equal_filecontent( "expected/test_verbatim.wiki", text.to_doc(:wiki,@opt))
     $log.warn("text-output for verbatim_array")
-    #~ assert_equal_filecontent( "expected/test_verbatim.text", text.to_doc(:text))
+    #~ assert_equal_filecontent( "expected/test_verbatim.text", text.to_doc(:text, @opt))
   end
 end #Test_Verbatim 
   
 class Test_CSS < Test::Unit::TestCase
-  include Temp_Logger  
+  def setup()
+    #Avoid warnings about missing logger in to_doc
+    @opt = { :log => DOCGENERATOR_DEFAULT_LOGGER } #unless defined? @opt
+  end
   def test_html_css()
     text = [
       element(:div,{}, [ 'Block 1',
@@ -510,34 +377,32 @@ class Test_CSS < Test::Unit::TestCase
             'Ende Block 1',
             ]).cr
       ]
-    assert_equal_filecontent( "expected/test_html_css.html", text.to_doc(:html))
+    assert_equal_filecontent( "expected/test_html_css.html", text.to_doc(:html, @opt))
   end
   def test_css()
     css = CSS.new(
                 :color => 'red',
                 :background_color => 'blue'
     )
-    assert_equal_filecontent( "expected/test_css.css", css.to_html)
+    assert_equal_filecontent( "expected/test_css.css", css.to_html(@opt))
     css[:float] = 'right'
-    assert_equal_filecontent( "expected/test_css2.css", css.to_html)
+    assert_equal_filecontent( "expected/test_css2.css", css.to_html(@opt))
   end
   #The data for CSS are checked, warnings and error are returned.
   def test_css_error()
-    templogfile = set_temporary_logger()
-    css = CSS.new( :color => 'red')
-    assert_equal('',  get_temporary_logger(templogfile))
+    css = CSS.new( :color => 'red', :log => $log_array)
+    assert_equal('',  $log_array_outputter.flush.join)
     
-    templogfile = set_temporary_logger()
     css[:color] = 'black'
-    assert_equal(" WARN docgenerator: CSS: Overwrite :color\n",  get_temporary_logger(templogfile))
+    assert_equal(" WARN docgenerator: CSS: Overwrite :color\n",  $log_array_outputter.flush.join)
 
-    templogfile = set_temporary_logger()
     css[:background_color] = 'nocolor'
-    assert_equal("ERROR docgenerator: CSS: nocolor not allowed for background-color\n",  get_temporary_logger(templogfile))
+    assert_equal("ERROR docgenerator: CSS: nocolor not allowed for background-color\n",  $log_array_outputter.flush.join)
 
-    templogfile = set_temporary_logger()
+    #logger must be reset to clear result for the test.
+    css = CSS.new( :color => 'red', :log => $log_array)
     css[:nonsense] = 'not valid'
-    assert_equal("ERROR docgenerator: CSS: Undefined key :nonsense\n",  get_temporary_logger(templogfile))
+    assert_equal("ERROR docgenerator: CSS: Undefined key :nonsense\n",  $log_array_outputter.flush.join)
     
   end
   def test_css_collection_anonym
@@ -546,7 +411,7 @@ class Test_CSS < Test::Unit::TestCase
       :font_size  => 'xx-small',
       :font_weight  => 'normal'
       ))
-    assert_equal_filecontent( "expected/css_collection_anonym.html", test.style.to_html)
+    assert_equal_filecontent( "expected/css_collection_anonym.html", test.style.to_html(@opt))
   end
   def test_css_collection
     CSS_collection.new(:test, 'CSS to test')
@@ -554,10 +419,10 @@ class Test_CSS < Test::Unit::TestCase
       :font_size  => 'xx-small',
       :font_weight  => 'normal'
       ))
-    assert_equal_filecontent( "expected/css_collection.html", CSS_collection[:test].style.to_html)
+    assert_equal_filecontent( "expected/css_collection.html", CSS_collection[:test].style.to_html(@opt))
   end
   def test_css_collection_toc
-    assert_equal_filecontent( "expected/toc_css.css", CSS_collection[:toc].style.to_html)
+    assert_equal_filecontent( "expected/toc_css.css", CSS_collection[:toc].style.to_html(@opt))
   end
 end
 
@@ -566,7 +431,10 @@ end
 #- The <<prefix>> is replaced by Document.save.
 #- With <<prefix>> we get always differences (timestamp)
 class Test_document < Test::Unit::TestCase
-  include Temp_Logger  
+  def setup()
+    #Avoid warnings about missing logger in to_doc
+    @opt = { :log => DOCGENERATOR_DEFAULT_LOGGER } #unless defined? @opt
+  end
   def test_document()
     doc = Document.new(
       :title => 'Testdokument',
@@ -641,7 +509,10 @@ class Test_document < Test::Unit::TestCase
   end
 end #Test_document < Test::Unit::TestCase
 class Test_document_toc < Test::Unit::TestCase
-  include Temp_Logger    
+  def setup()
+    #Avoid warnings about missing logger in to_doc
+    @opt = { :log => DOCGENERATOR_DEFAULT_LOGGER } #unless defined? @opt
+  end
   def test_document_toc()
     doc = Document.new(
       :title => 'Testdokument for toc-command'
@@ -661,14 +532,14 @@ class Test_document_toc < Test::Unit::TestCase
       element(:h1, {:id=>'sect3'}, 'Abschnitt 3' ).cr,
     ]
 
-    assert_equal_filecontent( "expected/test_document_toc_single.html", doc.toc( :tocfilename => 'test.html/').to_doc(:html))
-    assert_equal_filecontent( "expected/test_document_toc_single.latex", doc.toc().to_doc(:latex))
+    assert_equal_filecontent( "expected/test_document_toc_single.html", doc.toc( :tocfilename => 'test.html/').to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_document_toc_single.latex", doc.toc().to_doc(:latex, @opt))
     $log.warn('test_document_toc_single: to_context')
-    #~ assert_equal_filecontent( "expected/test_document_toc_single.context", doc.toc().to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_document_toc_single.context", doc.toc().to_doc(:context, @opt))
     $log.warn('test_document_toc_single: to_creole')
-    #~ assert_equal_filecontent( "expected/test_document_toc_single.creole", doc.toc().to_doc(:creole))
+    #~ assert_equal_filecontent( "expected/test_document_toc_single.creole", doc.toc().to_doc(:creole, @opt))
     #Normaly, the standard tableofcontents is used
-    assert_equal( "\\tableofcontents ", element(:tableofcontents).to_doc(:latex))
+    assert_equal( "\\tableofcontents ", element(:tableofcontents).to_doc(:latex, @opt))
     
    {
       :html => :html,
@@ -691,21 +562,21 @@ class Test_document_toc < Test::Unit::TestCase
     
     #Test with pre and post
     prepost = { :pre => 'Pretext', :post => 'Posttext' }
-    assert_equal_filecontent( "expected/test_document_toc_single_pre.html", doc.toc( prepost).to_doc(:html))
-    assert_equal_filecontent( "expected/test_document_toc_single_pre.latex", doc.toc(prepost).to_doc(:latex))
+    assert_equal_filecontent( "expected/test_document_toc_single_pre.html", doc.toc( prepost).to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_document_toc_single_pre.latex", doc.toc(prepost).to_doc(:latex, @opt))
     $log.warn('test_document_toc_single_pre: to_context')
-    #~ assert_equal_filecontent( "expected/test_document_toc_single_pre.context", doc.toc(prepost).to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_document_toc_single_pre.context", doc.toc(prepost).to_doc(:context, @opt))
     $log.warn('test_document_toc_single_pre: to_creole')
-    #~ assert_equal_filecontent( "expected/test_document_toc_single_pre.creole", doc.toc(prepost).to_doc(:creole))
+    #~ assert_equal_filecontent( "expected/test_document_toc_single_pre.creole", doc.toc(prepost).to_doc(:creole, @opt))
 
     testel = element(:ul,{},[element(:li,{},'1'),element(:li,{},'2')])
     prepost = { :pre => testel , :post => testel  }
-    assert_equal_filecontent( "expected/test_document_toc_single_pre2.html", doc.toc( prepost).to_doc(:html))
-    assert_equal_filecontent( "expected/test_document_toc_single_pre2.latex", doc.toc(prepost).to_doc(:latex))
+    assert_equal_filecontent( "expected/test_document_toc_single_pre2.html", doc.toc( prepost).to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_document_toc_single_pre2.latex", doc.toc(prepost).to_doc(:latex, @opt))
     $log.warn('test_document_toc_single_pre2: to_context')
-    #~ assert_equal_filecontent( "expected/test_document_toc_single_pre2.context", doc.toc(prepost).to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_document_toc_single_pre2.context", doc.toc(prepost).to_doc(:context, @opt))
     $log.warn('test_document_toc_single_pre2: to_creole')
-    #~ assert_equal_filecontent( "expected/test_document_toc_single_pre2.creole", doc.toc(prepost).to_doc(:creole))
+    #~ assert_equal_filecontent( "expected/test_document_toc_single_pre2.creole", doc.toc(prepost).to_doc(:creole, @opt))
   end
   def test_document_toc_deep()
     doc = Document.new(
@@ -725,26 +596,26 @@ class Test_document_toc < Test::Unit::TestCase
       element(:h4, {}, 'Abschnitt 2.1.1.1' ).cr,
       element(:h5, {}, 'Abschnitt 2.1.1.1.1' ).cr,    ]
     
-    assert_equal_filecontent( "expected/test_document_toc_deep.html", doc.toc().to_doc(:html))
-    assert_equal_filecontent( "expected/test_document_toc_deep.latex", doc.toc().to_doc(:latex))
+    assert_equal_filecontent( "expected/test_document_toc_deep.html", doc.toc().to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_document_toc_deep.latex", doc.toc().to_doc(:latex, @opt))
     $log.warn('test_document_toc_deep: to_context')
-    #~ assert_equal_filecontent( "expected/test_document_toc_deep.context", doc.toc().to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_document_toc_deep.context", doc.toc().to_doc(:context, @opt))
     $log.warn('test_document_toc_deep: to_creole')
-    #~ assert_equal_filecontent( "expected/test_document_toc_deep.creole", doc.toc().to_doc(:creole))
+    #~ assert_equal_filecontent( "expected/test_document_toc_deep.creole", doc.toc().to_doc(:creole, @opt))
 
-    assert_equal_filecontent( "expected/test_document_toc_deep_1.html", doc.toc(:level=>1).to_doc(:html))
-    assert_equal_filecontent( "expected/test_document_toc_deep_1.latex", doc.toc(:level=>1).to_doc(:latex))
+    assert_equal_filecontent( "expected/test_document_toc_deep_1.html", doc.toc(:level=>1).to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_document_toc_deep_1.latex", doc.toc(:level=>1).to_doc(:latex, @opt))
     $log.warn('test_document_toc_deep_1: to_context')
-    #~ assert_equal_filecontent( "expected/test_document_toc_deep_1.context", doc.toc(:level=>1).to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_document_toc_deep_1.context", doc.toc(:level=>1).to_doc(:context, @opt))
     $log.warn('test_document_toc_deep_1: to_creole')
-    #~ assert_equal_filecontent( "expected/test_document_toc_deep_1.creole", doc.toc(:level=>1).to_doc(:creole))
+    #~ assert_equal_filecontent( "expected/test_document_toc_deep_1.creole", doc.toc(:level=>1).to_doc(:creole, @opt))
 
-    assert_equal_filecontent( "expected/test_document_toc_deep_4.html", doc.toc(:level=>4).to_doc(:html))
-    assert_equal_filecontent( "expected/test_document_toc_deep_4.latex", doc.toc(:level=>4).to_doc(:latex))
+    assert_equal_filecontent( "expected/test_document_toc_deep_4.html", doc.toc(:level=>4).to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_document_toc_deep_4.latex", doc.toc(:level=>4).to_doc(:latex, @opt))
     $log.warn('test_document_toc_deep_4: to_context')
-    #~ assert_equal_filecontent( "expected/test_document_toc_deep_4.context", doc.toc(:level=>4).to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_document_toc_deep_4.context", doc.toc(:level=>4).to_doc(:context, @opt))
     $log.warn('test_document_toc_deep_4: to_creole')
-    #~ assert_equal_filecontent( "expected/test_document_toc_deep_4.creole", doc.toc(:level=>4).to_doc(:creole))
+    #~ assert_equal_filecontent( "expected/test_document_toc_deep_4.creole", doc.toc(:level=>4).to_doc(:creole, @opt))
     
   end
   def test_document_toc_deep_err()
@@ -770,28 +641,31 @@ class Test_document_toc < Test::Unit::TestCase
       element(:h4, {}, 'Abschnitt 3.1.1.1' ).cr,
     ]
     
-    templogfile = set_temporary_logger()
-    assert_equal_filecontent( "expected/test_document_toc_deep_err.html", doc.toc(:level=>4, :log => DOCGENERATOR_LOGGER).to_doc(:html))
-    assert_equal_filecontent( "expected/test_document_toc_deep_err.log",  get_temporary_logger(templogfile))
+    $log_array.level = Log4r::WARN    
+    assert_equal_filecontent( "expected/test_document_toc_deep_err.html", doc.toc(:level=>4, :log => $log_array).to_doc(:html, @opt))
+    assert_equal_filecontent( "expected/test_document_toc_deep_err.log",  $log_array_outputter.flush.join)
+    $log_array.level = Log4r::DEBUG #back again.
     
-    assert_equal_filecontent( "expected/test_document_toc_deep_err.latex", doc.toc().to_doc(:latex))
+    assert_equal_filecontent( "expected/test_document_toc_deep_err.latex", doc.toc().to_doc(:latex, @opt))
     $log.warn('test_document_toc_deep_err: to_context')
-    #~ assert_equal_filecontent( "expected/test_document_toc_deep_err.context", doc.toc().to_doc(:context))
+    #~ assert_equal_filecontent( "expected/test_document_toc_deep_err.context", doc.toc().to_doc(:context, @opt))
     $log.warn('test_document_toc_deep_err: to_creole')
-    #~ assert_equal_filecontent( "expected/test_document_toc_deep_err.creole", doc.toc().to_doc(:creole))
+    #~ assert_equal_filecontent( "expected/test_document_toc_deep_err.creole", doc.toc().to_doc(:creole, @opt))
 
   end
   
 end
 
 class Test_usepackage < Test::Unit::TestCase
-  include Temp_Logger  
+  def setup()
+    #Avoid warnings about missing logger in to_doc
+    @opt = { :log => DOCGENERATOR_DEFAULT_LOGGER } #unless defined? @opt
+  end
   #
   #If an unknown package is requested, you get an information.
   def test_usepackage_unknown()
-    templogfile = set_temporary_logger(Log4r::DEBUG)
-    element(:usepackage,{},'undefined package')
-    assert_equal_filecontent( "expected/test_document_usepackage_undefined.log",  get_temporary_logger(templogfile))
+    element(:usepackage,{:log => $log_array },'undefined package')
+    assert_equal_filecontent( "expected/test_document_usepackage_undefined.log",  $log_array_outputter.flush.join)
   end
   #Known packages 'require' new ruby packages.
   def test_usepackage_pdfpages()
@@ -803,10 +677,10 @@ class Test_usepackage < Test::Unit::TestCase
     req_diff = $" - old_required
     assert_equal( 1,  req_diff.size )
     #Ruby 1.9 has full path, Ruby 1.8 only require-parameter
-    assert_match( %r{packages/docgenerator_pdfpages.rb},  req_diff.first )
+    assert_match( %r{docgenerator/packages/pdfpages.rb},  req_diff.first )
 
-    assert_equal( '\usepackage{pdfpages}',  usepackage_element.to_latex)
-    assert_equal( '',  usepackage_element.to_html)
+    assert_equal( '\usepackage{pdfpages}',  usepackage_element.to_latex(@opt))
+    assert_equal( '',  usepackage_element.to_html(@opt))
 
   end  #test_usepackage_pdfpages()
 end