docgenerator 1.1.1 → 1.2.1

data/unittest/unittest_docgenerator.rb

@@ -1,9 +1,50 @@
-require 'test_docgenerator.rb'
+# encoding: utf-8
+require 'test/unit'
+$:.unshift('C:/usr/Script/more_unit_test/lib')
+require 'more_unit_test/assert_equal_filecontent.rb'
 
-Element.log = true 
+if $0 == __FILE__
+  $:.unshift("../lib")
+end
+require 'docgenerator'
+
+#~ 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 = 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
+  end
+end
+
+
+
 class Test_elements < Test::Unit::TestCase
   include Temp_Logger
   def test_generell_settings()
@@ -41,118 +82,173 @@ class Test_elements < Test::Unit::TestCase
     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_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)
   end
   def test_section()
     #~ log = Log4r::Logger.new( 'section_logger')
@@ -172,6 +268,10 @@ class Test_elements < Test::Unit::TestCase
     ]
     assert_equal_filecontent( "expected/test_section.html", text.to_doc(:html))
     assert_equal_filecontent( "expected/test_section.latex", text.to_doc(:latex))
+    $log.warn('test_section: to_context')
+    #~ assert_equal_filecontent( "expected/test_section.context", text.to_doc(:context))
+    $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))
   end
@@ -182,16 +282,20 @@ class Test_elements < Test::Unit::TestCase
     #~ log.outputters = Log4r::StdoutOutputter.new('test_section')
 
     text = [
-      element(:p, {}, [ 'Jetzt ein ', 
-          element(:label, { :name => 'ilink'}, 'Ziel'),
-          ' f�r einen Link',
+      element(:p, {}, [ 'Now a ', 
+          element(:label, { :name => 'ilink'}, 'target'),
+          ' for a link',
           ] ).cr,
-      element(:p, {}, [ 'Und hier der Textlink zum ', 
-          element(:a, {:href=>'#ilink'}, 'Ziel.'),
+      element(:p, {}, [ 'And here the text link to  ', 
+          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))
+    $log.warn('test_href: to_context')
+    #~ assert_equal_filecontent( "expected/test_href.context", text.to_doc(:context))
+    $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
   end
@@ -204,6 +308,9 @@ class Test_lists < Test::Unit::TestCase
         ])
     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))
+    $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))
   end
@@ -213,6 +320,9 @@ class Test_lists < Test::Unit::TestCase
         ])
     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))
+    $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))
   end
@@ -223,6 +333,10 @@ class Test_lists < Test::Unit::TestCase
         ])
     assert_equal_filecontent( "expected/test_description.html", description.to_doc(:html))
     assert_equal_filecontent( "expected/test_description.latex", description.to_doc(:latex))
+    $log.warn('test_description: to_context')
+    #~ assert_equal_filecontent( "expected/test_description.context", description.to_doc(:context))
+    $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))
   end
@@ -233,18 +347,22 @@ class Test_footnotes < Test::Unit::TestCase
     footnotegroup = Footnotegroup.new()
     #~ footnotegroup = nil
     text = [
-      element(:h1, {}, 'Abschnitt 1' ).cr,
+      element(:h1, {}, 'Section 1' ).cr,
       element(:par, {}, [ 
-              'Text zu Abschnitt 1',
-              element(:footnote,{ :group => footnotegroup }, 'Fu� eins'),
-              'Weiterer Text',
+              'Text in section 1',
+              element(:footnote,{ :group => footnotegroup }, 'Footnote one'),
+              'More Text',
               ]
       ).cr,
-      element(:h2, {}, 'Fu�noten' ).cr,
+      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))
+    $log.warn('test_footnote: to_context')
+    #~ assert_equal_filecontent( "expected/test_footnote.context", text.to_doc(:context))
+    $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))
   end #test_footnote
@@ -252,21 +370,25 @@ class Test_footnotes < Test::Unit::TestCase
     footnotegroup   = Footnotegroup.new()
     footnotegroup2 = Footnotegroup.new('g2')
     text = [
-      element(:h1, {}, 'Abschnitt 1' ).cr,
+      element(:h1, {}, 'Section 1' ).cr,
       element(:par, {}, [ 
-              'Text zu Abschnitt 1',
-              element(:footnote,{ :group => footnotegroup2 }, 'Fu� eins (g1)'),
-              'Weiterer Text',
-              element(:footnote,{ :group => footnotegroup}, 'Noch ne Fu�note'),
+              'Text in section 1',
+              element(:footnote,{ :group => footnotegroup2 }, 'Footnote one (g1)'),
+              'More Text',
+              element(:footnote,{ :group => footnotegroup}, 'Again a footnote'),
               ]
       ).cr,
-      element(:h2, {}, 'Fu�noten' ).cr,
+      element(:h2, {}, 'Footnotes' ).cr,
       footnotegroup,
-      element(:h3, {}, 'Fu�noten g1' ).cr,      
+      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))
+    $log.warn('test_footnote_group: to_context')
+    #~ assert_equal_filecontent( "expected/test_footnote_group.context", text.to_doc(:context))
+    $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))
   end #test_footnote
@@ -313,8 +435,12 @@ class Test_tabular < Test::Unit::TestCase
     #
     #~ $fixmes << "tabular/latex: tablines line 229 ../lib/docgenerator_tabular.rb#229"
     assert_equal_filecontent( "expected/test_tabular.latex", text.to_doc(:latex))
+    $log.warn('test_tabular: to_context')
+    #~ assert_equal_filecontent( "expected/test_tabular.context", text.to_doc(:context))
+    $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))
-    $fixmes << "text-output for tables"
+    $log.warn("text-output for tables")
     #~ assert_equal_filecontent( "expected/test_tabular.text", text.to_doc(:text))
   end
   def test_tabular_doc()
@@ -339,6 +465,37 @@ class Test_tabular < Test::Unit::TestCase
 end
 
 
+class Test_Verbatim < Test::Unit::TestCase
+    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))
+    $log.warn('test_verbatim: to_context')
+    #~ assert_equal_filecontent( "expected/test_verbatim.context", text.to_doc(:context))
+    $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))
+    $log.warn("text-output for verbatim")
+    #~ assert_equal_filecontent( "expected/test_verbatim.text", text.to_doc(:text))
+  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))
+    $log.warn('test_verbatim_array: to_context')
+    #~ assert_equal_filecontent( "expected/test_verbatim.context", text.to_doc(:context))
+    $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))
+    $log.warn("text-output for verbatim_array")
+    #~ assert_equal_filecontent( "expected/test_verbatim.text", text.to_doc(:text))
+  end
+end #Test_Verbatim 
+  
 class Test_CSS < Test::Unit::TestCase
   include Temp_Logger  
   def test_html_css()
@@ -422,13 +579,23 @@ class Test_document < Test::Unit::TestCase
     #~ doc.save('test_document.html')
     assert_instance_of( Log4r::Logger, doc.log)
     assert_not_same( DOCGENERATOR_LOGGER, doc.log)
+    
+    $log.warn('test_document: to_context')
+    $log.warn('test_document: to_creole')
     {
       :html => :html,
       :article => :latex,
+      #~ :context => :context,
       :wiki => :wiki,
+      #~ :creole => :creole,
       :text => :text,
     }.each{|template, target|
       filename = "test_document_#{template}.#{target}"
+      case target
+        when :text, :wiki, :creole
+          $log.warn('test_document: Supress errors for author, keywords...  fixme')
+          doc.log.level = Log4r::FATAL
+      end
       assert_equal_filecontent( "expected/#{filename}", 
                                 doc.to_doc(target, {
                                               :template=> DocumentTemplate[template],
@@ -458,6 +625,11 @@ class Test_document < Test::Unit::TestCase
       :text => :text,
     }.each{|template, target|
       filename = "test_document_replacement_#{template}.#{target}"
+      case target
+        when :text, :wiki
+        # Supress errors for author, keywords...  fixme
+          doc.log.level = Log4r::FATAL
+      end      
       assert_equal_filecontent( "expected/#{filename}", 
                                 doc.to_doc(target, {
                                               :template=> DocumentTemplate[template],
@@ -488,16 +660,22 @@ class Test_document_toc < Test::Unit::TestCase
       element(:p, {}, 'Text zu Abschnitt 2.1' ).cr,
       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))
+    $log.warn('test_document_toc_single: to_context')
+    #~ assert_equal_filecontent( "expected/test_document_toc_single.context", doc.toc().to_doc(:context))
+    $log.warn('test_document_toc_single: to_creole')
+    #~ assert_equal_filecontent( "expected/test_document_toc_single.creole", doc.toc().to_doc(:creole))
     #Normaly, the standard tableofcontents is used
     assert_equal( "\\tableofcontents ", element(:tableofcontents).to_doc(:latex))
     
    {
       :html => :html,
       :article => :latex,
+      #~ :context => :context,
       #~ :wiki => :wiki,
+      #~ :creole => :creole,
       #~ :text => :text,
     }.each{|template, target|
       filename = "test_document_toc_#{template}.#{target}"
@@ -515,11 +693,19 @@ class Test_document_toc < Test::Unit::TestCase
     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))
+    $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))
+    $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))
 
     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))
+    $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))
+    $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))
   end
   def test_document_toc_deep()
     doc = Document.new(
@@ -541,12 +727,24 @@ class Test_document_toc < Test::Unit::TestCase
     
     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))
+    $log.warn('test_document_toc_deep: to_context')
+    #~ assert_equal_filecontent( "expected/test_document_toc_deep.context", doc.toc().to_doc(:context))
+    $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_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))
+    $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))
+    $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_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))
+    $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))
+    $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))
     
   end
   def test_document_toc_deep_err()
@@ -554,6 +752,9 @@ class Test_document_toc < Test::Unit::TestCase
       :title => 'Testdokument for toc-command'
       )
 
+    # Supress WARN Doc: Toc: Jump over section level 1 () // fixme
+    doc.log.level = Log4r::ERROR
+
     doc.body << [
       element(:tableofcontents, {:as_list => true }).cr,
       #What happens if there are missing levels
@@ -562,22 +763,54 @@ class Test_document_toc < Test::Unit::TestCase
       element(:h3, {}, 'Abschnitt 1.1.1' ).cr,
       element(:h4, {}, 'Abschnitt 1.1.1.1' ).cr,
       element(:h1, {}, 'Abschnitt 2' ).cr,
-      # element(:h2, {}, 'Abschnitt 2.1' ).cr, #Jump over one levels
+      # element(:h2, {}, 'Abschnitt 2.1' ).cr, #Jump over one levels      
       element(:h3, {}, 'Abschnitt 2.1.1' ).cr,
       element(:h4, {}, 'Abschnitt 2.1.1.1' ).cr,
       element(:h1, {}, 'Abschnitt 3' ).cr,  #Jump over two levels
       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))
     
     assert_equal_filecontent( "expected/test_document_toc_deep_err.latex", doc.toc().to_doc(:latex))
+    $log.warn('test_document_toc_deep_err: to_context')
+    #~ assert_equal_filecontent( "expected/test_document_toc_deep_err.context", doc.toc().to_doc(:context))
+    $log.warn('test_document_toc_deep_err: to_creole')
+    #~ assert_equal_filecontent( "expected/test_document_toc_deep_err.creole", doc.toc().to_doc(:creole))
 
   end
   
 end
 
+class Test_usepackage < Test::Unit::TestCase
+  include Temp_Logger  
+  #
+  #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))
+  end
+  #Known packages 'require' new ruby packages.
+  def test_usepackage_pdfpages()
+
+    DOCGENERATOR_LOGGER.level = Log4r::FATAL
+    old_required = $".dup #Get old require list
+    usepackage_element = element(:usepackage,{},'pdfpages')
+    #Now a new require should be done
+    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_equal( '\usepackage{pdfpages}',  usepackage_element.to_latex)
+    assert_equal( '',  usepackage_element.to_html)
+
+  end  #test_usepackage_pdfpages()
+end
+
 #~ class Test_Element < Test::Unit::TestCase
   #~ def test_add_output()
 #~ cmd = <<'cmd'