rwv2 0.6.0

data/lib/rwv2/handlers.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+#
+# Rwv2 -- Microsoft Word Parser extension
+# Copyright (C) 2003 Hannes Wyss, ywesee - intellectual capital connected
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# ywesee - intellectual capital connected
+# Winterthurerstrasse 52, CH-8006 Z�rich, Switzerland
+# hwyss@ywesee.com
+#
+# Rwv2 -- Rwv2 -- 21.8.2003 -- hwyss@ywesee.com
+
+module Rwv2
+	class SubDocumentHandler
+		def body_start; end
+		def body_end; end
+		def footnote_start; end
+		def footnote_end; end
+		def headers_start; end
+		def headers_end; end
+		def header_start(header_data); end
+		def header_end; end
+	end
+	class TableHandler
+		def row_start(table_properties); end
+		def row_end; end
+		def cell_start; end
+		def cell_end; end
+	end
+	class TextHandler
+		def section_start(section_properties); end
+		def section_end; end
+		def page_break; end
+		def paragraph_start(paragraph_properties); end
+		def paragraph_end; end
+		def run_of_text(text, character_properties); end
+    def picture(pict); end
+	end
+end

data/lib/rwv2/rwv2.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+#
+# Rwv2 -- Microsoft Word Parser extension
+# Copyright (C) 2003 Hannes Wyss, ywesee - intellectual capital connected
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# ywesee - intellectual capital connected
+# Winterthurerstrasse 52, CH-8006 Z�rich, Switzerland
+# hwyss@ywesee.com
+## rwv2 -- rwv2 -- 24.09.2003 -- rwaltert@ywesee.com
+
+require 'rwv2'
+require 'rwv2/handlers'
+
+VERSION = '0.6.0'

data/rwv2-0.2.3.patch

@@ -0,0 +1,223 @@
+diff -Nur wv2-0.2.3/src/handlers.cpp wv2-0.2.3-p1/src/handlers.cpp
+--- wv2-0.2.3/src/handlers.cpp	2006-06-12 18:40:11.000000000 +0200
++++ wv2-0.2.3-p1/src/handlers.cpp	2008-02-18 18:20:26.000000000 +0100
+@@ -177,6 +177,11 @@
+ {
+ }
+ 
++void TextHandler::pictureData( SharedPtr<const Word97::PICF> /*picf*/,
++                               U8* /*buffer*/  )
++{
++}
++
+ void TextHandler::tableRowFound( const TableRowFunctor& tableRow, SharedPtr<const Word97::TAP> /*tap*/ )
+ {
+     tableRow();
+diff -Nur wv2-0.2.3/src/handlers.h wv2-0.2.3-p1/src/handlers.h
+--- wv2-0.2.3/src/handlers.h	2006-06-12 18:40:11.000000000 +0200
++++ wv2-0.2.3-p1/src/handlers.h	2008-02-18 18:20:30.000000000 +0100
+@@ -251,7 +251,9 @@
+          * Very special characters (bad, bad name) are the ones which need additional
+          * information from the file (i.e. the plain "put the current date there" isn't sufficent).
+          */
+-        enum VerySpecialCharacter { Picture = 1, FootnoteAuto = 2, FieldBegin = 19, FieldSeparator = 20,
++        enum VerySpecialCharacter { Picture = 1, FootnoteAuto = 2, 
++                                    Drawing = 8,
++                                    FieldBegin = 19, FieldSeparator = 20,
+                                     FieldEnd = 21, FieldEscapeChar = 92 };
+ 
+         /**
+@@ -299,6 +301,13 @@
+         virtual void fieldEnd( const FLD* fld, SharedPtr<const Word97::CHP> chp );
+ 
+         /**
++         * This method is called every time we find a picture.
++         * @param picf the picture-data.
++         */
++        virtual void pictureData( SharedPtr<const Word97::PICF> picf, 
++                                  U8* buffer);
++
++        /**
+          * This method is called every time we find a table row. The default
+          * implementation invokes the functor, which triggers the parsing
+          * process for the given table row.
+diff -Nur wv2-0.2.3/src/parser9x.cpp wv2-0.2.3-p1/src/parser9x.cpp
+--- wv2-0.2.3/src/parser9x.cpp	2006-06-12 18:40:11.000000000 +0200
++++ wv2-0.2.3-p1/src/parser9x.cpp	2008-02-20 17:32:03.000000000 +0100
+@@ -711,6 +711,7 @@
+             break;
+ 
+         // It has to be one of the very special characters...
++        case TextHandler::Drawing:
+         case TextHandler::Picture:
+             emitPictureData( chp );
+             break;
+@@ -812,7 +813,6 @@
+         picf = new Word97::PICF( Word95::toWord97( Word95::PICF( stream, false ) ) );
+     else
+         picf = new Word97::PICF( stream, false );
+-    stream->pop();
+ 
+     if ( picf->cbHeader < 58 ) {
+         wvlog << "Error: Found an image with a PICF smaller than 58 bytes! Skipping the image." << std::endl;
+@@ -838,8 +838,17 @@
+           << std::endl << " dxaOrigin=" << picf->dxaOrigin << " dyaOrigin="
+           << picf->dyaOrigin << std::endl;
+ #endif
+-    // for now
+-    delete picf;
++
++    /* extract the image blob */
++    stream->seek( chp->fcPic_fcObj_lTagObj + picf->cbHeader, G_SEEK_SET );
++    U32 len = picf->lcb - picf->cbHeader;
++    U8* buffer;
++    buffer = (U8 *)malloc(len * sizeof(U8));
++    stream->read(buffer, len);
++    m_textHandler->pictureData( picf, buffer );
++    free(buffer);
++
++    stream->pop();
+ }
+ 
+ void Parser9x::parseHeader( const HeaderData& data, unsigned char mask )
+diff -Nur wv2-0.2.3/src/styles.cpp wv2-0.2.3-p1/src/styles.cpp
+--- wv2-0.2.3/src/styles.cpp	2006-06-12 18:40:11.000000000 +0200
++++ wv2-0.2.3-p1/src/styles.cpp	2008-02-21 11:24:07.000000000 +0100
+@@ -445,6 +445,9 @@
+             parentStyle = stylesheet.styleByIndex( m_std->istdBase );
+             if ( parentStyle ) {
+                 const_cast<Style*>( parentStyle )->unwrapStyle( stylesheet, version );
++                // I'm getting Segfaults where there is no m_upechpx in parentStyle
++                if ( !parentStyle->m_upechpx )
++                  parentStyle->m_upechpx = new UPECHPX();
+                 bool ok;
+                 m_upechpx->istd = stylesheet.indexByID( m_std->sti, ok );
+                 mergeUpechpx( parentStyle, version );
+@@ -665,7 +668,7 @@
+     else if ( cbStshi == Word97::STSHI::sizeOf )
+         m_stsh.read( tableStream, false );
+     else {
+-        wvlog << "Detected a different STSHI, check this (trying to read Word97 one)" << std::endl;
++        wvlog << "Detected a different STSHI, check this (trying to read Word97 one - probably Latent Style Data added in Word2003)" << std::endl;
+         m_stsh.read( tableStream, false );
+     }
+ 
+diff -Nur wv2-0.2.3/src/word97_generated.h wv2-0.2.3-p1/src/word97_generated.h
+--- wv2-0.2.3/src/word97_generated.h	2006-06-12 18:40:12.000000000 +0200
++++ wv2-0.2.3-p1/src/word97_generated.h	2008-02-21 11:03:07.000000000 +0100
+@@ -8623,6 +8623,18 @@
+      */
+     U16 rgftcStandardChpStsh[3];
+ 
++
++    /** introduced in Word2003 **/
++    /**
++     * size of each lsd in mpstilsd. The count of lsd's is stiMaxWhenSaved 
++     */ 
++    //U16 cbLSD; 
++
++    /**
++     * latent style data (stiMax == stiMaxWhenSaved upon save!) 
++     */
++    //LSD mpstilsd[3]; 
++
+ }; // STSHI
+ 
+ bool operator==(const STSHI &lhs, const STSHI &rhs);
+diff -Nur wv2-0.2.3/src/word97_helper.cpp wv2-0.2.3-p1/src/word97_helper.cpp
+--- wv2-0.2.3/src/word97_helper.cpp	2006-06-12 18:50:45.000000000 +0200
++++ wv2-0.2.3-p1/src/word97_helper.cpp	2008-02-21 11:33:21.000000000 +0100
+@@ -1137,8 +1137,14 @@
+                 fBold = *ptr == 1;
+             else if ( *ptr == 128 && paragraphStyle )
+                 fBold = paragraphStyle->chp().fBold;
+-            else if ( *ptr == 129 && paragraphStyle )
+-                fBold = !( paragraphStyle->chp().fBold );
++            else if ( *ptr == 129 )
++                /**
++                 * there are some Word-Documents where the Nil Style seems to be 
++                 * defined as Reversed. Obviously the Nil Style has no 
++                 * ParentStyle, which is why I've moved the paragraphStyle-check
++                 * from the else if clause down to the next line.
++                 */ 
++                fBold = !( paragraphStyle && paragraphStyle->chp().fBold );
+             else
+                 wvlog << "Warning: sprmCFBold couldn't find a style" << std::endl;
+             break;
+@@ -1147,8 +1153,8 @@
+                 fItalic = *ptr == 1;
+             else if ( *ptr == 128 && paragraphStyle )
+                 fItalic = paragraphStyle->chp().fItalic;
+-            else if ( *ptr == 129 && paragraphStyle )
+-                fItalic = !( paragraphStyle->chp().fItalic );
++            else if ( *ptr == 129 )
++                fItalic = !( paragraphStyle && paragraphStyle->chp().fItalic );
+             else
+                 wvlog << "Warning: sprmCFItalic couldn't find a style" << std::endl;
+             break;
+@@ -1157,8 +1163,8 @@
+                 fStrike = *ptr == 1;
+             else if ( *ptr == 128 && paragraphStyle )
+                 fStrike = paragraphStyle->chp().fStrike;
+-            else if ( *ptr == 129 && paragraphStyle )
+-                fStrike = !( paragraphStyle->chp().fStrike );
++            else if ( *ptr == 129 )
++                fStrike = !( paragraphStyle && paragraphStyle->chp().fStrike );
+             else
+                 wvlog << "Warning: sprmCFStrike couldn't find a style" << std::endl;
+             break;
+@@ -1167,8 +1173,8 @@
+                 fOutline = *ptr == 1;
+             else if ( *ptr == 128 && paragraphStyle )
+                 fOutline = paragraphStyle->chp().fOutline;
+-            else if ( *ptr == 129 && paragraphStyle )
+-                fOutline = !( paragraphStyle->chp().fOutline );
++            else if ( *ptr == 129 )
++                fOutline = !( paragraphStyle && paragraphStyle->chp().fOutline );
+             else
+                 wvlog << "Warning: sprmCFOutline couldn't find a style" << std::endl;
+             break;
+@@ -1177,8 +1183,8 @@
+                 fShadow = *ptr == 1;
+             else if ( *ptr == 128 && paragraphStyle )
+                 fShadow = paragraphStyle->chp().fShadow;
+-            else if ( *ptr == 129 && paragraphStyle )
+-                fShadow = !( paragraphStyle->chp().fShadow );
++            else if ( *ptr == 129 )
++                fShadow = !( paragraphStyle && paragraphStyle->chp().fShadow );
+             else
+                 wvlog << "Warning: sprmCFShadow couldn't find a style" << std::endl;
+             break;
+@@ -1187,8 +1193,8 @@
+                 fSmallCaps = *ptr == 1;
+             else if ( *ptr == 128 && paragraphStyle )
+                 fSmallCaps = paragraphStyle->chp().fSmallCaps;
+-            else if ( *ptr == 129 && paragraphStyle )
+-                fSmallCaps = !( paragraphStyle->chp().fSmallCaps );
++            else if ( *ptr == 129 )
++                fSmallCaps = !( paragraphStyle && paragraphStyle->chp().fSmallCaps );
+             else
+                 wvlog << "Warning: sprmCFSmallCaps couldn't find a style" << std::endl;
+             break;
+@@ -1197,8 +1203,8 @@
+                 fCaps = *ptr == 1;
+             else if ( *ptr == 128 && paragraphStyle )
+                 fCaps = paragraphStyle->chp().fCaps;
+-            else if ( *ptr == 129 && paragraphStyle )
+-                fCaps = !( paragraphStyle->chp().fCaps );
++            else if ( *ptr == 129 )
++                fCaps = !( paragraphStyle && paragraphStyle->chp().fCaps );
+             else
+                 wvlog << "Warning: sprmCFCaps couldn't find a style" << std::endl;
+             break;
+@@ -1207,8 +1213,8 @@
+                 fVanish = *ptr == 1;
+             else if ( *ptr == 128 && paragraphStyle )
+                 fVanish = paragraphStyle->chp().fVanish;
+-            else if ( *ptr == 129 && paragraphStyle )
+-                fVanish = !( paragraphStyle->chp().fVanish );
++            else if ( *ptr == 129 )
++                fVanish = !( paragraphStyle && paragraphStyle->chp().fVanish );
+             else
+                 wvlog << "Warning: sprmCFVanish couldn't find a style" << std::endl;
+             break;

data/test/data/not_a_word_document.rtf

@@ -0,0 +1,16 @@
+{\rtf1\ansi\deff0\adeflang1025
+{\fonttbl{\f0\froman\fprq2\fcharset0 Times New Roman;}{\f1\froman\fprq2\fcharset0 Times New Roman;}{\f2\fnil\fprq2\fcharset0 Arial;}{\f3\fnil\fprq0\fcharset0 Times New Roman;}{\f4\fnil\fprq2\fcharset0 HG Mincho Light J{\*\falt msmincho};}{\f5\fnil\fprq2\fcharset0 Lucidasans;}{\f6\fnil\fprq0\fcharset0 Lucidasans;}}
+{\colortbl;\red0\green0\blue0;\red128\green128\blue128;}
+{\stylesheet{\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\rtlch\af5\afs24\lang255\ltrch\dbch\af2\langfe255\hich\f0\fs24\lang2057\loch\f0\fs24\lang2057\snext1 Normal;}
+{\s2\sb240\sa120\keepn\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\rtlch\afs28\lang255\ltrch\dbch\af4\langfe255\hich\f3\fs28\lang2057\loch\f3\fs28\lang2057\sbasedon1\snext3 Heading;}
+{\s3\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\rtlch\af5\afs24\lang255\ltrch\dbch\af2\langfe255\hich\f0\fs24\lang2057\loch\f0\fs24\lang2057\sbasedon1\snext3 Body Text;}
+{\s4\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\rtlch\af6\afs24\lang255\ltrch\dbch\af2\langfe255\hich\f0\fs24\lang2057\loch\f0\fs24\lang2057\sbasedon3\snext4 List;}
+{\s5\sb120\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\rtlch\af6\afs24\lang255\ai\ltrch\dbch\af2\langfe255\hich\f0\fs24\lang2057\i\loch\f0\fs24\lang2057\i\sbasedon1\snext5 caption;}
+{\s6\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\rtlch\af6\afs24\lang255\ltrch\dbch\af2\langfe255\hich\f0\fs24\lang2057\loch\f0\fs24\lang2057\sbasedon1\snext6 Index;}
+}
+{\info{\author Hannes Wyss}{\creatim\yr2008\mo2\dy19\hr11\min34}{\revtim\yr0\mo0\dy0\hr0\min0}{\printim\yr0\mo0\dy0\hr0\min0}{\comment StarWriter}{\vern6800}}\deftab709
+{\*\pgdsctbl
+{\pgdsc0\pgdscuse195\pgwsxn12240\pghsxn15840\marglsxn1134\margrsxn1134\margtsxn1134\margbsxn1134\pgdscnxt0 Standard;}}
+\paperh15840\paperw12240\margl1134\margr1134\margt1134\margb1134\sectd\sbknone\pgwsxn12240\pghsxn15840\marglsxn1134\margrsxn1134\margtsxn1134\margbsxn1134\ftnbj\ftnstart1\ftnrstcont\ftnnar\aenddoc\aftnrstcont\aftnstart1\aftnnrlc
+\pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\rtlch\af5\afs24\lang255\ltrch\dbch\af2\langfe255\hich\f0\fs24\lang2057\loch\f0\fs24\lang2057 {\rtlch \ltrch\loch\f0\fs24\lang2057\i0\b0 An RTF-File}
+\par }

data/test/test_parser.rb

@@ -0,0 +1,644 @@
+#!/usr/bin/env ruby
+#
+# Rwv2 -- Microsoft Word Parser extension
+# Copyright (C) 2003 Hannes Wyss, ywesee - intellectual capital connected
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# ywesee - intellectual capital connected
+# Winterthurerstrasse 52, CH-8006 Z�rich, Switzerland
+# hwyss@ywesee.com
+#
+# TestParser -- Rwv2 -- 21.8.2003 -- hwyss@ywesee.com
+
+$: << File.expand_path('../ext/rwv2', File.dirname(__FILE__))
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'rwv2/rwv2'
+require 'RMagick'
+require 'iconv'
+
+class StubInlineReplacementHandler
+	attr_accessor :non_required_hyphen
+	def column_break
+		"c"
+	end
+	def hard_line_break
+		"\n"
+	end
+	def non_breaking_hyphen
+		"="
+	end
+	def non_breaking_space
+		"_"
+	end
+	def tab
+		"t"
+	end
+end
+class StubIncompleteReplacementHandler
+	def hard_line_break
+		"\n"
+	end
+end
+["body", "footnote", "headers", "header"].each { |tpe|
+	eval <<-EOF
+	class StubSubDocumentHandler
+		attr_reader :#{tpe}_starts, :#{tpe}_ends
+		def #{tpe}_start
+			@#{tpe}_starts ||= 0
+			@#{tpe}_starts += 1
+		end
+		def #{tpe}_end
+			@#{tpe}_ends ||= 0
+			@#{tpe}_ends += 1
+		end
+	end
+	EOF
+}
+class StubSubDocumentHandler
+	attr_reader :header_starts
+	def initialize
+		@header_starts = []
+	end
+	def header_start(header_type)
+		@header_starts << header_type
+	end
+end
+class StubTextHandler
+	attr_accessor :texts, :formats, :section_properties, :section_ends
+	attr_accessor :page_breaks, :paragraph_properties, :paragraph_ends, :pictures
+	def initialize
+    @iconv = Iconv.new('utf8', 'utf-16')
+    @pictures = []
+		@formats = []
+		@texts = []
+		@section_properties = []
+		@paragraph_properties = []
+		@section_ends = 0
+		@paragraph_ends = 0
+		@page_breaks = 0
+	end
+  def picture(picture)
+    @pictures.push picture
+  end
+	def section_start(sep)
+		@section_properties << sep
+	end
+	def section_end
+		@section_ends += 1
+	end
+	def page_break
+		@page_breaks += 1
+	end
+	def paragraph_start(pap)
+		@paragraph_properties << pap
+	end
+	def paragraph_end
+		@paragraph_ends += 1
+	end
+	def run_of_text(text, format=nil)
+		@formats << format unless format.nil?
+		@texts << @iconv.iconv(text)
+	end
+end
+class StubTableHandler
+	attr_reader :row_starts, :row_ends, :cell_starts, :cell_ends
+	def initialize
+		@row_starts = []
+		@row_ends = 0
+		@cell_starts = 0
+		@cell_ends = 0
+	end
+	def row_start(properties=nil)
+		@row_starts << properties
+	end
+	def row_end
+		@row_ends += 1
+	end
+	def cell_start
+		@cell_starts += 1
+	end
+	def cell_end
+		@cell_ends += 1
+	end
+end
+
+class TestRwv2Parser < Test::Unit::TestCase
+	def setup
+		@filename = File.expand_path('data/test.doc', File.dirname(__FILE__))
+		@filename2 = File.expand_path('data/test2.doc', File.dirname(__FILE__))
+		@filename3 = File.expand_path('data/test3.doc', File.dirname(__FILE__))
+		@filename4 = File.expand_path('data/test4.doc', File.dirname(__FILE__))
+		@filename5 = File.expand_path('data/test5.doc', File.dirname(__FILE__))
+		@filename6 = File.expand_path('data/test6.doc', File.dirname(__FILE__))
+		@filename7 = File.expand_path('data/test7.doc', File.dirname(__FILE__))
+		@filename8 = File.expand_path('data/test8.doc', File.dirname(__FILE__))
+		@filename9 = File.expand_path('data/test9.doc', File.dirname(__FILE__))
+		@unavailable = File.expand_path('data/unavailable.doc', File.dirname(__FILE__))
+		@rtf = File.expand_path('data/not_a_word_document.rtf', File.dirname(__FILE__))
+		@ir_handler = StubInlineReplacementHandler.new
+		@ir_handler.non_required_hyphen = "-"
+	end
+	def test_create_parser
+		assert_nothing_raised {
+			Rwv2.create_parser(@filename)
+		}
+		assert_nothing_raised {
+			Rwv2.create_parser_from_content(File.read(@filename))
+		}
+	end
+	def test_inline_replacement_handler
+		parser = Rwv2.create_parser(@filename)
+		handler = StubTextHandler.new
+		parser.set_text_handler(handler)
+		assert_nothing_raised {
+			parser.set_inline_replacement_handler(@ir_handler)
+		}
+		parser.parse
+		expected = [
+			"Paragraph 1, Standard",
+			"Paragraph 2, Bold",
+			"Paragraph 3, Italic",
+			"Paragraph 4, Underlined",
+			"Paragraph 5, Bold Italic",
+			"Paragraph 6, Bold Underlined",
+			"Paragraph 7, Italic Underlined",
+			"Paragraph 8, Bold Italic Underlined",
+			"Paragraph 9, ",
+			"mixed Formats",
+			"TabtTab",
+			"HardLineBreak\nHardLineBreak",
+			"ColumnBreakcColumnBreak",
+			"NonBreakingHyphen=NonBreakingHyphen",
+			"NonRequiredHyphen-NonRequiredHyphen",
+			"NonBreakingSpace",
+			"_",
+			"NonBreakingSpace",
+		]
+		assert_equal(expected, handler.texts)
+	end
+	def test_incomplete_replacement_handler
+		parser = Rwv2.create_parser(@filename)
+		handler = StubTextHandler.new
+		parser.set_text_handler(handler)
+		replacer = StubIncompleteReplacementHandler.new
+		assert_nothing_raised {
+			parser.set_inline_replacement_handler(replacer)
+		}
+		parser.parse
+		expected = [
+			"Paragraph 1, Standard",
+			"Paragraph 2, Bold",
+			"Paragraph 3, Italic",
+			"Paragraph 4, Underlined",
+			"Paragraph 5, Bold Italic",
+			"Paragraph 6, Bold Underlined",
+			"Paragraph 7, Italic Underlined",
+			"Paragraph 8, Bold Italic Underlined",
+			"Paragraph 9, ",
+			"mixed Formats",
+			"Tab\tTab",
+			"HardLineBreak\nHardLineBreak",
+			"ColumnBreak\016ColumnBreak",
+			"NonBreakingHyphen\036NonBreakingHyphen", 
+			"NonRequiredHyphen\037NonRequiredHyphen", 
+			"NonBreakingSpace", 
+			"\302\240", 
+			"NonBreakingSpace"
+		]
+		assert_equal(expected, handler.texts)
+	end
+	def test_illegal_replacement_handler
+		parser = Rwv2.create_parser(@filename)
+		handler = StubTextHandler.new
+		parser.set_text_handler(handler)
+		parser.set_inline_replacement_handler(@ir_handler)
+		@ir_handler.non_required_hyphen = ""
+		assert_raises(RuntimeError) {
+			parser.parse
+		}
+		@ir_handler.non_required_hyphen = "--"
+		assert_raises(RuntimeError) {
+			parser.parse
+		}
+	end
+	def test_subdocument_handler
+		parser = Rwv2.create_parser(@filename4)
+		handler = StubSubDocumentHandler.new
+		assert_nothing_raised {
+			parser.set_subdocument_handler(handler)
+		}
+		parser.parse
+		assert_equal(1, handler.body_starts)
+		assert_equal(1, handler.body_ends)
+		assert_equal(1, handler.footnote_starts)
+		assert_equal(1, handler.footnote_ends)
+		assert_equal(1, handler.headers_starts)
+		assert_equal(1, handler.headers_ends)
+		assert_equal(2, handler.header_ends)
+		assert_equal([Rwv2::HEADER_ODD, Rwv2::FOOTER_ODD], handler.header_starts)
+	end
+	def test_table_handler
+		parser = Rwv2.create_parser(@filename5)
+		handler = StubTableHandler.new
+		assert_nothing_raised {
+			parser.set_table_handler(handler)
+		}
+		parser.parse
+		assert_equal(6, handler.row_ends)
+		assert_equal(11, handler.cell_starts)
+		assert_equal(11, handler.cell_ends)
+		head = handler.row_starts.at(0)
+		row0 = handler.row_starts.at(1)
+		row1 = handler.row_starts.at(2)
+		row2 = handler.row_starts.at(3)
+		row3 = handler.row_starts.at(4)
+		row4 = handler.row_starts.at(5)
+		assert_equal(283, row0.row_height)
+		assert_equal(-283, row1.row_height)
+		assert_equal(2, head.row_cells)
+		assert_equal(2, row0.row_cells)
+		assert_equal(2, row1.row_cells)
+		assert_equal(1, row2.row_cells)
+		assert_equal(2, row3.row_cells)
+		assert_equal(2, row4.row_cells)
+		assert_equal(3, row0.cell_boundaries.size)
+		assert_equal(0, row0.cell_boundaries.at(0))
+		assert_equal(4818, row0.cell_boundaries.at(1))
+		assert_equal(9639, row0.cell_boundaries.at(2))
+		assert_equal(2, row0.cell_descriptors.size)
+		ct0 = row0.cell_descriptors.first
+		cta = row0.cell_descriptors.last
+		ctb = row1.cell_descriptors.first
+		assert_instance_of(Rwv2::TableProperties::CellDescriptor, ct0)
+		assert_equal(false, ct0.first_merged?)
+		assert_equal(Rwv2::TableProperties::CellDescriptor::ALIGN_TOP, ct0.vertical_align)
+		assert_equal(Rwv2::TableProperties::CellDescriptor::ALIGN_CENTER, cta.vertical_align)
+		assert_equal(Rwv2::TableProperties::CellDescriptor::ALIGN_BOTTOM, ctb.vertical_align)
+		ct2 = row3.cell_descriptors.first
+		assert_equal(true, ct2.vertical_merged?)
+		assert_equal(true, ct2.vertical_restart?)
+		# ct2 = row3.cell_descriptors.first
+		# assert_equal(true, ct2.vertical)
+
+		# FIXME: the following are untested, 
+		#	       need a _real_ Wordfile to test...
+		# assert_equal(Rwv2::TableProperties::ALIGN_LEFT, row0.align)
+		# assert_equal(Rwv2::TableProperties::ALIGN_LEFT, row1.align)
+		# row0.gap_half
+		# assert_equal(true, row0.cant_split)
+		# assert_equal(false, row1.cant_split)
+		# ct1 = row2.cell_descriptors.first
+		# assert_equal(true, ct1.merged)
+		# assert_equal(true, ct1.first_merged)
+		# :rotate_font, :backward, :vertical_merged,
+		# :vertical_restart, :vertical_align
+	end
+	def test_text_handler
+		parser = Rwv2.create_parser(@filename)
+		handler = StubTextHandler.new
+		assert_nothing_raised {
+			parser.set_text_handler(handler)
+		}
+		parser.parse
+		expected = [
+			"Paragraph 1, Standard",
+			"Paragraph 2, Bold",
+			"Paragraph 3, Italic",
+			"Paragraph 4, Underlined",
+			"Paragraph 5, Bold Italic",
+			"Paragraph 6, Bold Underlined",
+			"Paragraph 7, Italic Underlined",
+			"Paragraph 8, Bold Italic Underlined",
+			"Paragraph 9, ",
+			"mixed Formats",
+			"Tab\tTab",
+			"HardLineBreak\vHardLineBreak",
+			"ColumnBreak\016ColumnBreak",
+			"NonBreakingHyphen\036NonBreakingHyphen", 
+			"NonRequiredHyphen\037NonRequiredHyphen", 
+			"NonBreakingSpace", 
+			"\302\240", 
+			"NonBreakingSpace"
+		]
+		assert_equal(expected, handler.texts)
+		paps = handler.paragraph_properties
+		assert_equal(16, paps.size)
+		assert_equal(16, handler.paragraph_ends)
+		pap0 = paps.at(0)
+		pap1 = paps.at(1)
+		pap2 = paps.at(2)
+		pap3 = paps.at(3)
+		pap4 = paps.at(4)
+		pap5 = paps.at(5)
+		pap6 = paps.at(6)
+		assert_instance_of(Rwv2::ParagraphProperties, pap0)
+		assert_equal(Rwv2::ALIGN_LEFT, pap0.align)
+		assert_equal(Rwv2::ALIGN_CENTER, pap1.align)
+		assert_equal(Rwv2::ALIGN_RIGHT, pap2.align)
+		assert_equal(Rwv2::ALIGN_JUSTIFY, pap3.align)
+		assert_equal(true, pap0.keep?)
+		assert_equal(false, pap0.keep_with_next?)
+		assert_equal(false, pap0.widow_control?)
+		assert_equal(false, pap1.keep?)
+		assert_equal(true, pap1.keep_with_next?)
+		assert_equal(false, pap1.widow_control?)
+		assert_equal(false, pap2.keep?)
+		assert_equal(false, pap2.keep_with_next?)
+		assert_equal(true, pap2.widow_control?)
+		assert_equal(false, pap3.keep?)
+		assert_equal(false, pap3.keep_with_next?)
+		assert_equal(false, pap3.widow_control?)
+		# FIXME does this work with a real Wordfile?
+		# assert_equal(false, pap0.page_break_before?)
+		# assert_equal(false, pap1.page_break_before?)
+		# assert_equal(false, pap2.page_break_before?)
+		# assert_equal(true, pap3.page_break_before?)
+		assert_equal(1680, pap4.indent_right)
+		assert_equal(0, pap4.indent_left)
+		assert_equal(0, pap4.indent_first_line)
+		assert_equal(0, pap5.indent_right)
+		assert_equal(570, pap5.indent_left)
+		assert_equal(0, pap5.indent_first_line)
+		assert_equal(0, pap6.indent_right)
+		assert_equal(570, pap6.indent_left)
+		assert_equal(-285, pap6.indent_first_line)
+	end
+	def test_incomplete_text_handler
+		parser = Rwv2.create_parser(@filename)
+		handler = Rwv2::TextHandler.new
+		parser.set_text_handler(handler)
+		assert_nothing_raised { parser.parse }
+	end
+	def test_character_properties
+		parser = Rwv2.create_parser(@filename)
+		handler = StubTextHandler.new
+		parser.set_text_handler(handler)
+		parser.parse
+		formats = handler.formats
+		assert_equal(false, formats.empty?, 
+			"The Parser recorded no Character Properties")
+		bold = handler.formats.collect { |fmt| fmt.bold? } 
+		expected = [1,4,5,7,9] 
+		assert_equal(expected, index_select(formats, :bold?))
+		expected = [2,4,6,7]
+		assert_equal(expected, index_select(formats, :italic?))
+	end
+	def test_character_properties2
+		parser = Rwv2.create_parser(@filename2)
+		handler = StubTextHandler.new
+		parser.set_text_handler(handler)
+		parser.parse
+		expected = [ 
+			"The ", "new Text!", 
+			"This will be deleted.", 
+			"Outlined", 
+			"Small Caps", 
+			"Caps", 
+			"Strikethrough", 
+			"Shadow", 
+			"Lower Case", 
+			"Embossed", 
+			"Engraved", 
+			"Double Strikethrough",
+		]
+		assert_equal(expected, handler.texts)
+		formats = handler.formats
+		assert_equal(false, formats.empty?, 
+			"The Parser recorded no Character Properties")
+		assert_equal([0,1], index_select(formats, :rev_mark?))
+		assert_equal([2], index_select(formats, :rev_mark_del?))
+		assert_equal([3], index_select(formats, :outline?))
+		assert_equal([4], index_select(formats, :small_caps?))
+		assert_equal([5], index_select(formats, :caps?))
+		assert_equal([6], index_select(formats, :strikethrough?))
+		assert_equal([7], index_select(formats, :shadow?))
+		#assert_equal([8], index_select(formats, :lowercase?)) # FIXME 
+		# our test-file is made with Openoffice - which does not set the
+		# lowercase-flag in Word Files...
+		assert_equal([9], index_select(formats, :emboss?))
+		assert_equal([10], index_select(formats, :imprint?))
+		assert_equal([11], index_select(formats, :double_strikethrough?))
+	end
+	def test_character_properties3
+		parser = Rwv2.create_parser(@filename3)
+		handler = StubTextHandler.new
+		parser.set_text_handler(handler)
+		parser.parse
+		expected = [ 
+			"Normal", 
+			"Superscript",
+			"Subscript",
+			"Single",
+			"By Word",
+			"Double",
+			"Dotted",
+			"Thick",
+			"Dash",
+			"Dot Dash",
+			"Dot Dot Dash",
+			"Wave",
+		]
+		assert_equal(expected, handler.texts)
+		formats = handler.formats
+		assert_equal(false, formats.empty?, 
+			"The Parser recorded no Character Properties")
+		assert_equal(Rwv2::CharacterProperties::POSITION_NORMAL, formats[0].position)
+		assert_equal(Rwv2::CharacterProperties::POSITION_SUPERSCRIPT, formats[1].position)
+		assert_equal(Rwv2::CharacterProperties::POSITION_SUBSCRIPT, formats[2].position)
+		assert_equal(false, formats[0].underline)
+		#assert_equal([3,4,5,6,7,8,9,10,11], index_select(formats, :underline)) # FIXME
+		# Openoffice saves simple underline somewhere else?
+		assert_equal([4,5,6,7,8,9,10,11], index_select(formats, :underline)) # FIXME
+		assert_equal(Rwv2::CharacterProperties::UNDERLINE_NONE, formats[0].underline)
+		#assert_equal(Rwv2::CharacterProperties::UNDERLINE_SINGLE, formats[3].underline) # FIXME
+		assert_equal(Rwv2::CharacterProperties::UNDERLINE_BY_WORD, formats[4].underline) 
+		assert_equal(Rwv2::CharacterProperties::UNDERLINE_DOUBLE, formats[5].underline) 
+		assert_equal(Rwv2::CharacterProperties::UNDERLINE_DOTTED, formats[6].underline) 
+		assert_equal(Rwv2::CharacterProperties::UNDERLINE_THICK, formats[7].underline) 
+		assert_equal(Rwv2::CharacterProperties::UNDERLINE_DASH, formats[8].underline) 
+		assert_equal(Rwv2::CharacterProperties::UNDERLINE_DOT_DASH, formats[9].underline) 
+		assert_equal(Rwv2::CharacterProperties::UNDERLINE_DOT_DOT_DASH, formats[10].underline) 
+		assert_equal(Rwv2::CharacterProperties::UNDERLINE_WAVE, formats[11].underline) 
+		assert_equal(100, formats[0].scale)
+		assert_equal(24, formats[0].fontsize)
+	end
+	def test_section_properties
+		parser = Rwv2.create_parser(@filename6)
+		handler = StubTextHandler.new
+		parser.set_text_handler(handler)
+		parser.parse
+		properties = handler.section_properties
+		assert_equal(5, properties.size)
+		assert_equal(5, handler.section_ends)
+		assert_equal(1, handler.page_breaks)
+		sect0 = properties.at(0)
+		sect1 = properties.at(1)
+		sect2 = properties.at(2)
+		sect3 = properties.at(3)
+		sect4 = properties.at(4)
+		assert_instance_of(Rwv2::SectionProperties, sect0)
+		assert_equal(Rwv2::SectionProperties::NUMBER_ARABIC, sect0.page_number_format)
+		assert_equal(false, sect0.title_page?)
+		assert_equal(false, sect0.unlocked?)
+		assert_equal(false, sect0.page_number_restart?)
+		assert_equal(false, sect0.line_numbering_modulus)
+		assert_equal(1, sect0.columns)
+		assert_equal(2, sect1.columns)
+		assert_equal(3, sect2.columns)
+		assert_equal(2, sect3.columns)
+		assert_equal(1, sect4.columns)
+
+		# FIXME: get a real wordfile...
+		# assert_equal(Rwv2::SectionProperties::BREAK_NONE, sect0.break_code)
+		# assert_equal(Rwv2::SectionProperties::BREAK_NONE, sect1.break_code)
+		# assert_equal(Rwv2::SectionProperties::BREAK_NONE, sect2.break_code)
+		# assert_equal(Rwv2::SectionProperties::BREAK_NONE, sect3.break_code)
+		# assert_equal(Rwv2::SectionProperties::BREAK_NONE, sect4.break_code)
+		# assert_equal(Rwv2::SectionProperties::LINE_NUMBERING_PER_PAGE, sect0.line_numbering_code)
+		# assert_equal(true, sect0.endnote?)
+		# assert_equal(true, sect1.endnote?)
+		# assert_equal(false, sect2.endnote?)
+		# assert_equal(true, sect3.endnote?)
+	end
+	def test_gc
+		parser = Rwv2.create_parser(@filename)
+		parser.set_inline_replacement_handler(@ir_handler.dup)
+		parser.set_subdocument_handler(StubSubDocumentHandler.new)
+		parser.set_text_handler(StubTextHandler.new)
+		GC.start
+		sleep(0.5)
+		assert_nothing_raised {
+			parser.parse
+		}
+	end
+	def test_tab_descriptors
+		parser = Rwv2.create_parser(@filename7)
+		handler = StubTextHandler.new
+		assert_nothing_raised {
+			parser.set_text_handler(handler)
+		}
+		parser.parse
+		paps = handler.paragraph_properties
+		pap0 = paps.at(0)
+		assert_instance_of(Rwv2::ParagraphProperties, pap0)
+		tabs = pap0.tab_descriptors
+		assert_equal(4, tabs.size)
+		tab0, tab1, tab2, tab3 = tabs
+		assert_instance_of(Rwv2::TabDescriptor, tab0)
+		assert_equal(1410, tab0.position)
+		assert_equal(2835, tab1.position)
+		assert_equal(4230, tab2.position)
+		assert_equal(5655, tab3.position)
+		assert_equal(Rwv2::TabDescriptor::ALIGN_LEFT, tab0.align)
+		assert_equal(Rwv2::TabDescriptor::ALIGN_RIGHT, tab1.align)
+		assert_equal(Rwv2::TabDescriptor::ALIGN_CENTER, tab3.align)
+		# FIXME
+		# assert_equal(Rwv2::TabDescriptor::ALIGN_DECIMAL, tab2.align)
+	end
+	def test_unavailable
+		assert_raises(Errno::ENOENT) {
+			Rwv2.create_parser(@unavailable)
+		}
+	end
+	def test_invalid__rtf
+		assert_raises(ArgumentError) { 
+			Rwv2.create_parser(@rtf)
+		}
+    begin
+			Rwv2.create_parser(@rtf)
+    rescue ArgumentError => err
+      assert_equal(sprintf("'#@rtf' is not a word-document."), err.message)
+    end
+	end
+  def test_invalid__rtf__from_content
+    assert_raises(ArgumentError) { 
+      Rwv2.create_parser_from_content(File.read(@rtf))
+    }
+    begin
+      Rwv2.create_parser_from_content(File.read(@rtf))
+    rescue ArgumentError => err
+      assert_equal(sprintf("Input is not a word-document."), err.message)
+    end
+  end
+  def test_picture__word95
+    ## later openoffice formats don't work yet.
+		handler = StubTextHandler.new
+		parser = Rwv2.create_parser(@filename8)
+		assert_nothing_raised {
+			parser.set_text_handler(handler)
+		}
+		assert_nothing_raised {
+      parser.parse
+    }
+    assert_equal(2, handler.pictures.size)
+
+    desc = handler.pictures.at(0)
+    assert_instance_of(Rwv2::PictureDescriptor, desc)
+    assert_equal(1146, desc.display_width)
+    assert_equal(1147, desc.display_height)
+    assert_equal(999, desc.scaling_horizontal)
+    assert_equal(999, desc.scaling_vertical)
+    assert_equal(0, desc.crop_left)
+    assert_equal(0, desc.crop_top)
+    assert_equal(0, desc.crop_right)
+    assert_equal(0, desc.crop_bottom)
+    assert_equal(false, desc.is_bitmap?)
+    assert_equal(false, desc.is_active_ole_object?)
+
+    pic, = Magick::Image.from_blob(desc.blob)
+    assert_equal(38, pic.rows)
+    assert_equal(38, pic.columns)
+
+    desc = handler.pictures.at(1)
+    assert_instance_of(Rwv2::PictureDescriptor, desc)
+    assert_equal(1145, desc.display_width)
+    assert_equal(1146, desc.display_height)
+    assert_equal(999, desc.scaling_horizontal)
+    assert_equal(999, desc.scaling_vertical)
+    assert_equal(0, desc.crop_left)
+    assert_equal(0, desc.crop_top)
+    assert_equal(0, desc.crop_right)
+    assert_equal(0, desc.crop_bottom)
+    assert_equal(false, desc.is_bitmap?)
+    assert_equal(false, desc.is_active_ole_object?)
+
+    pic, = Magick::Image.from_blob(desc.blob)
+    assert_equal(38, pic.rows)
+    assert_equal(38, pic.columns)
+  end
+  def test_special_characters
+    parser = Rwv2.create_parser(@filename9)
+    handler = StubTextHandler.new
+    assert_nothing_raised {
+      parser.set_text_handler(handler)
+    }
+    parser.parse
+    expected = [
+      "Ligature: \305\223",
+    ]
+    assert_equal(expected, handler.texts)
+  end
+	# helper methods
+	def index_select(collection, symbol)
+		res = []
+		collection.each_with_index { |item, idx|
+			(res << idx) if(item.send(symbol))
+		}
+		res
+	end
+end