docgenerator 0.1.1 → 1.0.2

data/unittest/test_docgenerator.rb

@@ -0,0 +1,85 @@
+require 'test/unit'
+require 'tempfile'  #needed to get logger.data
+
+
+$: << '../lib'
+require 'docgenerator'
+require 'wiki2doc/wiki2docgenerator'
+puts "==> Version #{DOCGENERATOR_VERSION}"
+
+$fixmes = []
+#
+# Mag nicht
+#
+#~ END{ 
+  #~ puts 'Fixmes:'
+  #~ puts     $fixmes.join("\n")
+#~ }
+
+require 'ftools'
+class Test::Unit::TestCase
+  #
+  #Takes the content of the file 'filename' and compares it with 'actual' like in assert_equal.
+  #If 'filname' doesn't exist, the failure 
+  # Reference file <#{filename}> missing
+  #is returned.
+  #
+  #'folder_for_failure' will contain all results with differences.
+  #
+  #What will happen:
+  #1) text.to_doc(:html) is the  test. It creates some HTML-Text
+  #2) "expected/test_section.html" is read and compared to text.to_doc(:html)
+  #2a)  If the file is missing -> error
+  #2b) If it is the same -> fine 
+  #2c) If there are differences:
+  #3) A message is given (like in assert_equal)
+  #4) A folder "failure#{Date.today}" is created if not already exist
+  #5) The file 'test_section.html' with the result is created in "failure#{Date.today}/"
+  #6) I can use a compare tool to compare the expected result and the real result.
+  #
+  #Recommendation to build up your test.
+  #1) Create two folders: 'expected' and 'failure'
+  #2) Define your assertion with a non-existing filename
+  #3) Run the test with folder_for_failure = 'failure'
+  #4) You will get a failure (reference file is missing).
+  #5) Copy the file in 'failure' to 'expected'
+  #6) Rerun again, you have no failure (hopefully ;-) )
+  def assert_equal_filecontent( filename, actual, folder_for_failure = "failure#{Date.today}", message = nil )
+    if File.exist?(filename)
+      expected = File.read(filename) 
+      full_message = build_message(message, "<?> expected (#{filename}) but was\n<?>.\n", expected, actual)
+    else
+      full_message = "Reference file <#{filename}> missing"
+    end
+    #Write the real result to a file.
+    #Folder is defined with Test::Unit::TestCase#folder_for_failure
+    if folder_for_failure and expected  != actual
+      File.makedirs(folder_for_failure) if ! File.directory?(folder_for_failure)
+      File.open( "#{folder_for_failure}/#{File.basename(filename)}", 'w'){|f|
+        f << actual
+      }
+    end
+    assert_block( full_message ){ expected  == actual }
+  end
+  #
+end
+
+#~ #
+#~ # Little helper. assert_equal with another order of data.
+#~ # Reason: The here-documents must be the last parameter in a method call.
+#~ #
+#~ def assert_equal_reverse( code, expectedresult )
+    #~ assert_equal( expectedresult, code )
+#~ end
+#~ # Little helper. assert_equal with another order of data.
+#~ # Reason: The here-documents must be the last parameter in a method call.
+#~ #
+#~ def assert_equal_reverse_chomp( code, expectedresult )
+    #~ assert_equal( expectedresult.chomp, code )
+#~ end
+  
+
+if $0 == __FILE__
+#~ require 'unittest_docgenerator.rb'
+#~ require 'unittest_wiki2doc.rb'
+end

data/unittest/unittest_docgenerator.rb

@@ -0,0 +1,454 @@
+require 'test_docgenerator.rb'
+
+Element.log = true 
+#~ DOCGENERATOR_LOGGER.level = Log4r::DEBUG
+#~ DOCGENERATOR_LOGGER.level = Log4r::ERROR
+
+
+class Test_elements < Test::Unit::TestCase
+  #Redirect Logger data to temporary file
+  def set_temporary_logger()
+    templogfile = Tempfile.new("xxx_warn.log")
+    @loglevel = DOCGENERATOR_LOGGER.level
+    @outputter = DOCGENERATOR_LOGGER.outputters.first
+    DOCGENERATOR_LOGGER.level = Log4r::WARN    
+    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.to_s
+    templogfile.close(true)    
+    DOCGENERATOR_LOGGER.level = @loglevel 
+    DOCGENERATOR_LOGGER.outputters = @outputter
+    return templogfile_content
+  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_instance_of( Log4r::StdoutOutputter, DOCGENERATOR_LOGGER.outputters.first)
+    #~ assert_equal( Log4r::FATAL, DOCGENERATOR_LOGGER.outputters.first.level)
+  end
+  def test_content_flag()
+    #~ log = Log4r::Logger.new( 'Flags')
+    #~ log.level = Log4r::ERROR
+    #~ log.level = Log4r::DEBUG
+    #~ log.outputters = Log4r::StdoutOutputter.new('test_section')
+
+    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 methden
+    templogfile = set_temporary_logger()
+    assert_equal( "<br />", element(:br,{},'content').to_html)
+    #~ assert_equal_filecontent( "expected/test_content.log", get_temporary_logger() )
+    assert_equal(%Q{ WARN docgenerator: Add content to an element without this feature ["br/", :br, :newline, "br"], "content"\n},  get_temporary_logger(templogfile))
+  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(:ensp).to_latex)
+    assert_equal( '&emsp;', element(:bigspace).to_html)
+    assert_equal( '&emsp;', element(:emsp).to_html)
+    assert_equal( '~~', element(:bigspace).to_latex)
+    assert_equal( '~~', element(:emsp).to_latex)
+    assert_equal( '&nbsp;', element(:nbsp).to_html)
+    assert_equal( '~', element(:nbsp).to_latex)
+    assert_equal( '&euro;', element(:euro).to_html)
+    assert_equal( '\euro', element(:euro).to_latex)
+    assert_equal( '%', element(:percent).to_html)
+    assert_equal( '%', element(:'%').to_html)
+    assert_equal( '\%', element(:percent).to_latex)
+    assert_equal( '\%', element(:'%').to_latex)
+    assert_equal( '^', element(:'^').to_html)
+    assert_equal( '\hat{}', element(:'^').to_latex)
+    assert_equal( '&iquest;', element(:iquest).to_html)
+    assert_equal( '�', element(:iquest).to_latex)
+    assert_equal( '&amp;', element(:ampersand).to_html)
+    assert_equal( '&amp;', element(:'&').to_html)
+    assert_equal( '\&', element(:ampersand).to_latex)
+    assert_equal( '\&', element(:'&').to_latex)
+    assert_equal( '}', element(:rbrace).to_html)
+    assert_equal( '}', element(:'}').to_html)
+    assert_equal( '\}', element(:rbrace).to_latex)
+    assert_equal( '\}', element(:'}').to_latex)
+    assert_equal( '{', element(:lbrace).to_html)
+    assert_equal( '{', element(:'{').to_html)
+    assert_equal( '\{', element(:lbrace).to_latex)
+    assert_equal( '\{', element(:'{').to_latex)
+    assert_equal( '\\', element(:backslash).to_html)
+    assert_equal( '\ensuremath{\backslash}', element(:backslash).to_latex)
+    assert_equal( '&radic;', element(:radic).to_html)
+    assert_equal( '\ensuremath{\sqrt{}}', element(:radic).to_latex)
+    assert_equal( '&rarr;', element(:rarr).to_html)
+    assert_equal( '&rarr;', element(:rightarrow).to_html)
+    assert_equal( '&rarr;', element(:'->').to_html)
+    assert_equal( '\ensuremath{\rightarrow}', element(:rarr).to_latex)
+    assert_equal( '\ensuremath{\rightarrow}', element(:rightarrow).to_latex)
+    assert_equal( '\ensuremath{\rightarrow}', element(:'->').to_latex)
+    assert_equal( '&rArr;', element(:rArr).to_html)
+    assert_equal( '&rArr;', element(:Rightarrow).to_html)
+    assert_equal( '&rArr;', element(:'=>').to_html)
+    assert_equal( '\ensuremath{\Rightarrow}', element(:rArr).to_latex)
+    assert_equal( '\ensuremath{\Rightarrow}', element(:Rightarrow).to_latex)
+    assert_equal( '\ensuremath{\Rightarrow}', element(:'=>').to_latex)
+    assert_equal( '&larr;', element(:larr).to_html)
+    assert_equal( '&larr;', element(:leftarrow).to_html)
+    assert_equal( '&larr;', element(:'<-').to_html)
+    assert_equal( '\ensuremath{\leftarrow}', element(:larr).to_latex)
+    assert_equal( '\ensuremath{\leftarrow}', element(:leftarrow).to_latex)
+    assert_equal( '\ensuremath{\leftarrow}', element(:'<-').to_latex)
+    assert_equal( '&lArr;', element(:lArr).to_html)
+    assert_equal( '&lArr;', element(:Leftarrow).to_html)
+    assert_equal( '&lArr;', element(:'<=').to_html)
+    assert_equal( '\ensuremath{\Lefttarrow}', element(:lArr).to_latex)
+    assert_equal( '\ensuremath{\Lefttarrow}', element(:Leftarrow).to_latex)
+    assert_equal( '\ensuremath{\Lefttarrow}', element(:'<=').to_latex)
+    assert_equal( '&uArr;', element(:uArr).to_html)
+    assert_equal( '&uArr;', element(:Uparrow).to_html)
+    assert_equal( '\ensuremath{\Uparrow}', element(:uArr).to_latex)
+    assert_equal( '\ensuremath{\Uparrow}', element(:Uparrow).to_latex)
+    assert_equal( '&lt;', element(:lt).to_html)
+    assert_equal( '&lt;', element(:'<').to_html)
+    assert_equal( '\ensuremath{<}', element(:lt).to_latex)
+    assert_equal( '\ensuremath{<}', element(:'<').to_latex)
+    assert_equal( '&gt;', element(:gt).to_html)
+    assert_equal( '&gt;', element(:'>').to_html)
+    assert_equal( '\ensuremath{>}', element(:gt).to_latex)
+    assert_equal( '\ensuremath{>}', element(:'>').to_latex)
+    assert_equal( '&infin;', element(:infin).to_html)
+    assert_equal( '&infin;', element(:infty).to_html)
+    assert_equal( '\ensuremath{\infty}', element(:infin).to_latex)
+    assert_equal( '\ensuremath{\infty}', element(:infty).to_latex)
+    assert_equal( '&divide;', element(:divide).to_html)
+    assert_equal( '\ensuremath{\div}', element(:divide).to_latex)
+    assert_equal( '&yen;', element(:yen).to_html)
+    assert_equal( '&sim;', element(:sim).to_html)
+    assert_equal( '\ensuremath{\sim}', element(:sim).to_latex)
+    assert_equal( '&brvbar;', element(:brvbar).to_html)
+    assert_equal( '|', element(:brvbar).to_latex)
+    assert_equal( '5&euro;', element(:euros,{},5).to_html)
+    assert_equal( '\euros{5}', element(:euros,{},5).to_latex)
+    assert_equal( '&not;', element(:neg).to_html)
+    assert_equal( '&not;', element(:not).to_html)
+    assert_equal( '\ensuremath{\neg}', element(:neg).to_latex)
+    assert_equal( '\ensuremath{\neg}', element(:not).to_latex)
+    assert_equal( '&times;', element(:times).to_html)
+    assert_equal( '\ensuremath{\times}', element(:times).to_latex)
+    assert_equal( '&otimes;', element(:otimes).to_html)
+    assert_equal( '\ensuremath{\otimes}', element(:otimes).to_latex)
+    assert_equal( '&empty;', element(:empty).to_html)
+    assert_equal( '\ensuremath{\emptyset}', element(:empty).to_latex)
+    assert_equal( '_', element(:'_').to_html)
+    assert_equal( '_', element(:underscore).to_html)
+    assert_equal( '\_', element(:'_').to_latex)
+    assert_equal( '\_', element(:underscore).to_latex)
+    assert_equal( '&#149;', element(:bullet).to_html)
+    assert_equal( '\ensuremath{\bullet}', element(:bullet).to_latex)
+    assert_equal( '&ndash;', element(:'--').to_html)
+    assert_equal( '&ndash;', element(:ndash).to_html)
+    assert_equal( '--', element(:'--').to_latex)
+    assert_equal( '--', element(:ndash).to_latex)
+    assert_equal( '&mdash;', element(:'---').to_html)
+    assert_equal( '&mdash;', element(:mdash).to_html)
+    assert_equal( '---', element(:'---').to_latex)
+    assert_equal( '---', element(:mdash).to_latex)
+    assert_equal( '&dagger;', element(:dagger).to_html)
+    assert_equal( '\dag', element(:dagger).to_latex)
+  end
+  def test_section()
+    #~ log = Log4r::Logger.new( 'section_logger')
+    #~ log.level = Log4r::ERROR
+    #~ log.level = Log4r::DEBUG
+    #~ log.outputters = Log4r::StdoutOutputter.new('test_section')
+
+    text = [
+      element(:h1, {}, 'Abschnitt 1' ).cr,
+      element(:par, {}, 'Text zu Abschnitt 1' ).cr,
+      element(:h2, {}, 'Abschnitt 1.1' ).cr,
+      element(:p, {}, 'Text zu Abschnitt 1.1' ).cr,
+      element(:h1, {}, 'Abschnitt 2' ).cr,
+      element(:par, {}, 'Text zu Abschnitt 2' ).cr,
+      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.wiki", text.to_doc(:wiki))
+    assert_equal_filecontent( "expected/test_section.text", text.to_doc(:text))
+  end
+  def test_href()
+    #~ log = Log4r::Logger.new( 'section_logger')
+    #~ log.level = Log4r::ERROR
+    #~ log.level = Log4r::DEBUG
+    #~ log.outputters = Log4r::StdoutOutputter.new('test_section')
+
+    text = [
+      element(:p, {}, [ 'Jetzt ein ', 
+          element(:label, { :name => 'ilink'}, 'Ziel'),
+          ' f�r einen Link',
+          ] ).cr,
+      element(:p, {}, [ 'Und hier der Textlink zum ', 
+          element(:a, {:href=>'#ilink'}, 'Ziel.'),
+          ] ).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.wiki", text.to_doc(:wiki))
+    assert_equal_filecontent( "expected/test_href.text", text.to_doc(:text))  #not good
+  end
+end #Test_elements 
+
+class Test_lists < Test::Unit::TestCase
+  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.wiki", ul.to_doc(:wiki))
+    assert_equal_filecontent( "expected/test_itemize.text", ul.to_doc(:text))
+  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.wiki", ol.to_doc(:wiki))
+    assert_equal_filecontent( "expected/test_enumerate.text", ol.to_doc(:text))
+  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.wiki", description.to_doc(:wiki))
+    assert_equal_filecontent( "expected/test_description.text", description.to_doc(:text))
+  end
+end #Test_lists 
+
+class Test_footnotes < Test::Unit::TestCase
+  def test_footnote
+    text = [
+      element(:h1, {}, 'Abschnitt 1' ).cr,
+      element(:par, {}, [ 
+              'Text zu Abschnitt 1',
+              element(:footnote,{}, 'Fu� eins'),
+              'Weiterer Text',
+              ]
+      ).cr,
+      element(:h2, {}, 'Fu�noten' ).cr,
+      Footnotegroup.get,
+    ]
+    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.wiki", text.to_doc(:wiki))
+    #~ assert_equal_filecontent( "expected/test_footnote.text", text.to_doc(:text))
+  end #test_footnote
+  def test_footnote_group
+    Footnotegroup.clear()
+    text = [
+      element(:h1, {}, 'Abschnitt 1' ).cr,
+      element(:par, {}, [ 
+              'Text zu Abschnitt 1',
+              element(:footnote,{ :groupid => 'g1' }, 'Fu� eins (g1)'),
+              'Weiterer Text',
+              element(:footnote,{}, 'Noch ne Fu�note'),
+              ]
+      ).cr,
+      element(:h2, {}, 'Fu�noten' ).cr,
+      Footnotegroup.get,
+      element(:h3, {}, 'Fu�noten g1' ).cr,      
+      Footnotegroup.get('g1'),
+    ]
+    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.wiki", text.to_doc(:wiki))
+    #~ assert_equal_filecontent( "expected/test_footnote_group.text", text.to_doc(:text))
+  end #test_footnote
+end #Test_footnotes
+
+class Test_tabular < Test::Unit::TestCase
+  def mk_tabular( columns, lines )
+    
+    tab = element(:tabular, {
+            :columns => columns.size, #for HTML
+            :columndescription =>	'c' * columns.size  #for LaTeX
+          } ).CR
+
+    tab 	<< row = element( :row, {:add_vspace=>'1ex'}  ).cr
+    row	<< element(:multicolumn, {
+          :columns	=> columns.size,
+          :pos		=> 'c', #LaTeX
+        }, 'Titel over all columns' )
+    row.hline #Only LaTeX
+    tab 	<< row = element( :row, {:add_vspace=>'1ex'}  ).cr
+    row	<< multicol = element(:multicolumn, {
+          :pos		=> 'c', #LaTeX
+        }, 'SubTitel over all columns' )
+    multicol[:columns] <<columns.size
+    row.hline #Only LaTeX
+    
+    lines.each{|line|
+      tab 		<< row = element( :row ).cr
+      columns.each{|column|
+        row		<< element(:column, {}, "#{line}#{column}" )
+      }
+    }
+    return tab
+  end
+  def test_tabular()
+    text = mk_tabular( Array('A'..'D'), Array(1..5) )
+    assert_equal_filecontent( "expected/test_tabular.html", text.to_doc(:html))
+    #The line ends will be \\\\
+    #In usage in documents, it's converted into \\.
+    #
+    #~ doc = Document.new()
+    #~ doc.body << text.to_doc(:latex)
+    #~ 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.wiki", text.to_doc(:wiki))
+    $fixmes << "text-output for tables"
+    #~ assert_equal_filecontent( "expected/test_tabular.text", text.to_doc(:text))
+  end
+  def test_tabular_doc()
+    doc = Document.new()
+    doc.body << mk_tabular( Array('A'..'D'), Array(1..5) )
+    #~ doc.save('Test.tex', true)  #\\ is ok
+    
+    #~ 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))
+    
+    #The row ends in tabulars are \\.
+    #When used in documents, \\ is  converted into \.
+    #So there is a special rule to double the \\ when used in combination with a filename.
+    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))
+  end
+end
+
+
+class Test_HTML < Test::Unit::TestCase
+  def test_html_css()
+    text = [
+      element(:div,{}, [ 'Block 1',
+            element(:span,{ 
+                  :style => CSS.new(
+                                :background_color => 'blue',
+                                :color => 'red'
+                  )
+                }, 'Zwischenblock' ),
+            'Ende Block 1',
+            ]).cr
+      ]
+    assert_equal_filecontent( "expected/test_html_css.html", text.to_doc(:html))
+    #~ assert_equal_filecontent( "expected/test_block.latex", text.to_doc(:latex))
+    #~ assert_equal_filecontent( "expected/test_block.wiki", text.to_doc(:wiki))
+    #~ assert_equal_filecontent( "expected/test_block.text", text.to_doc(:text))
+  end
+  def test_css()
+    css = CSS.new(
+                :color => 'red',
+                :background_color => 'blue'
+    )
+    assert_equal_filecontent( "expected/test_css.css", css.to_s)
+    css[:float] = 'right'
+    assert_equal_filecontent( "expected/test_css2.css", css.to_html)
+  end
+end
+#~ class TestBeamer < Test::Unit::TestCase
+  #~ def test_beamer_note()
+    #~ text = element(:note,{}, 'Notiz').cr
+
+    #~ assert_equal_filecontent( "expected/test_beamer_note.html", text.to_doc(:html))
+    #~ assert_equal_filecontent( "expected/test_beamer_note.latex", text.to_doc(:latex))
+    #~ assert_equal_filecontent( "expected/test_beamer_note.wiki", text.to_doc(:wiki))
+    #~ assert_equal_filecontent( "expected/test_beamer_note.text", text.to_doc(:text))
+
+  #~ end
+#~ end #TestBeamer
+
+#
+#Remark:
+#- The <<prefix>> is replaced by Document.save.
+#- With <<prefix>> we get always differences (timestamp)
+class Test_document < Test::Unit::TestCase
+  def test_document()
+    doc = Document.new(
+      :title => 'Testdokument',
+      :keywords => 'Test',
+      :description => 'This is a test for a Document, generated by docgenerator.rb',
+      :author => 'docgenerator.rb',
+      :maketitle  => true
+      )
+    doc.body << element(:p,{}, 'This is some content' )
+    #~ doc.save('test_document.html')
+    assert_instance_of( Log4r::Logger, doc.log)
+    assert_not_same( DOCGENERATOR_LOGGER, doc.log)
+    {
+      :html => :html,
+      :article => :latex,
+      :wiki => :wiki,
+      :text => :text,
+    }.each{|template, target|
+      filename = "test_document_#{template}.#{target}"
+      assert_equal_filecontent( "expected/#{filename}", 
+                                doc.to_doc(target, {
+                                              :template=> DocumentTemplate[template],
+                                              :filename => filename,
+                                              #~ :replacements => replacements,
+                                              :log  => doc.log
+                                            }))
+    }
+  end
+  def test_doc_with_replacement()
+    doc = Document.new(
+      :title => 'Testdokument',
+      :keywords => 'Test',
+      :description => 'This is a test for a Document, generated by docgenerator.rb',
+      :author => 'docgenerator.rb',
+      :maketitle  => true
+      )
+    doc.body << element(:p,{}, 'This is some content' )
+    #~ doc.save('test_document.html')
+    assert_instance_of( Log4r::Logger, doc.log)
+    assert_not_same( DOCGENERATOR_LOGGER, doc.log)
+    {
+      :html => :html,
+      :article => :latex,
+      :wiki => :wiki,
+      :text => :text,
+    }.each{|template, target|
+      filename = "test_document_replacement_#{template}.#{target}"
+      assert_equal_filecontent( "expected/#{filename}", 
+                                doc.to_doc(target, {
+                                              :template=> DocumentTemplate[template],
+                                              :filename => filename,
+                                              :replacements => {/This is some content/ => 'Etwas Inhalt' },
+                                              :log  => doc.log
+                                            }))
+    }
+  end
+end